When is async/await needed in writing to socket in python asnycio.Protocol?

Question

I'm confused as to when and why the async/await syntax would be needed, or not, when using the low level asyncio.Protocol approach in python. Suppose I have a subclass of asyncio.Protocol, say EchoClientProtocol, and that has a method send_message that external code can use to send any message to an echo server. For example:

import asyncio

class EchoClientProtocol(asyncio.Protocol):
    def __init__(self, message):
        self.transport = None
        self.message = message

    def send_message(self,txt):
        self.message = txt
        self.transport.write(self.message.encode())
        print('Data sent: {!r}'.format(self.message))

    def connection_made(self, transport):
        self.transport=transport
        self.send_message(self.message)

    def data_received(self, data):
        print('Data received: {!r}'.format(data.decode()))

    def connection_lost(self, exc):
        print('The server closed the connection')
        self.on_con_lost.set_result(True)

We can create and run the client with code that uses the familiar async/away syntax, with some auto-reconnect logic built in:

async def main():
    while True:
        try:
            message="Initial message here"
            transport, protocol = await loop.create_connection(
                lambda: EchoClientProtocol(message),
                '127.0.0.1', 
                8888
            )
        except OSError:
            print("Server not up, retrying in 5 seconds...")
            await asyncio.sleep(5)
        else:
            break

loop = asyncio.get_event_loop()
asyncio.run(main())

The above client class EchoClientProtocol does not declare send_message as async, and does not await the self.transport.write() method. I have seen code like this in many examples online. Why would this work if it uses asyncio? Isn't the async/await syntax necessary? Why or why not?

Suppose I have two clients in the same python script and both have to run simultaneously without blocking each other. For example, suppose that one echo client connects to a server at port 8888 and another connect to another client server at port 8899. I can use async.gather to make sure that both run simultaneously, but in that case do I have to declare send_message as async, and do I have to await self.transport.write()? In other words, what would I have to change in the EchoClientProtocol above so that I could run two or more such clients in the same script (connecting to different servers on different ports) to make them both run without blocking each other?