Well, kind of... The hardware can send one byte at a time. After that one byte you have to load another. This can be done either by waiting around (are you ready yet? Are you ready yet?) after each byte so you can send the next or, you can do it via interrupts where you load a byte and then go do whatever else you want. Then when the hardware is ready for another character it fires an interrupt and if the serial buffer has a character it will automatically load it and resume your program again. This is faster from your program's perspective as you aren't sitting around waiting to send characters.
Because I wanted interrupt driven serial transmission I helped to get that added to the Due core a couple of years back. So, all the UARTS on the Due are interrupt driven for both receive and transmit. This means if you are sending less characters than the buffer size (128 bytes) your program will immediately return when you call something like Serial.write or Serial.println. And that means you can then go do Serial2.print immediately. This will cause them both to send at the same time. However, if you start sending a lot of data and you cause a back up (say, you sent 100 bytes then almost immediately try to send 100 more) then it will block on whichever serial port you are trying to send too much data to. All serial ports with pending transmissions will still be sending at the same time but you won't get back to your program until the plugged up data is cleared out. In the above example you are sending 200 characters but the buffer is 128 long. The first character gets sent immediately so you can take 129 characters right away. That leaves 71 characters pending. The routine will thus block for 71 bytes or about 710 bit times. During this time interrupts fire and all serial ports will send but if the rest had only a little bit of data then they'll run out of characters while you are still clearing out the 71 extra characters. Once you get to the end of the 71 characters (with 128 characters still buffered) the routine will exit and you'll be able to run your program again.
So, the answer is that you can send on multiple serial interfaces right this second but you must ensure you do not buffer up more than 128 characters to any serial port or you'll face a blockage.
I hope this thoroughly answers the question.