Interfacing three UART devices to Microcontroller without loss of data
Your software design is not good and is probably the reason that incoming bytes are being lost.

First, I'm not sure whether this is a bug or a typo.  You disable interrupts at the beginning of Timer1IntHandler() but then you only re-enable interrupts if Correct is true.  Don't you want to re-enable interrupts before returning regardless of the conditional?  It seems strange that interrupts could be left disabled when the function returns.

It appears that your code reads characters from UART1 only within the ReadJoystick() function.  And I suspect that UART1 is not read while all those functions from GenerateServoCardsFrame() to SendJoystickFrame() are called.  How long does it take for those functions to run?  Could those functions take long enough for the UART1 FIFO to fill up and overflow?  This could be when incoming bytes are getting dropped.

If I was designing this software I would implement it completely differently than what you have done.  I would enable the UART interrupt request and create a quick UART interrupt handler routine.  The only thing the UART ISR would do is to copy bytes to/from the UART TX/RX registers.  I would create two circular (a.k.a. ring) buffers to hold the bytes.  The UART ISR would copy a recieved byte from the UART RX register to the RX circular buffer.  And the UART ISR would copy a byte to transmit from the TX circular buffer to the UART TX register.  The UART ISR would not attempt to interpret the meaning of any of the bytes.  All it does is move bytes between the RAM buffers and the UART peripheral.  This keeps the UART ISR short, which allows the overall program to be more response to other interrupts.

Then I would create a main() function with an infinite loop and within the infinite loop I would call a function called SerialReceive() to read messages out of the RX buffer.  SerialReceive() would be implemented as a state machine.  If any bytes are available in the RX buffer then it will process a finite number of bytes through the state machine.  The state machine would have states for the frame header, body and trailer similar to what you've done.  SerialReceive() returns immediately when either a message is completed or no more bytes are available.  When a message is incomplete because no more bytes are immediately available then SerialReceive() won't wait for them, instead it will remember the current state and message so that it can continue with the same message when it is called again from main().

If you need to do something periodically then setup a timer like you have done, but rather than doing all the work within the timer ISR, just set a flag instead.  The main infinite loop should repeatedly check the flag and do whatever is appropriate when the flag has been set by the timer ISR.  Doing the work from the context of main() means that the system can respond to other interrupts while it is doing the work.

Keeping ISRs short allows the overall system to be more responsive to other interrupt requests.  If you spend too much time in an ISR, like I believe you are doing in your timer ISR, then the system will not be responsive.

Update:
In your comment you say that those functions loop until transmits are complete and they take over 7 milliseconds.  That's enough time for 80 bytes to arrive at the UART and your code is not reading those bytes during this time so of course bytes will be lost.

Your transmitting functions should copy bytes into the TX buffer and return without waiting for the entire message to be transmitted.  The UART ISR should transmit one byte each invocation while the TX buffer contains bytes.

The RX and TX buffer should be larger than any message.  Typically the buffers are a power-of-two in size because that makes it easy to circle the buffer pointers around back to the beginning.  So make them 256 bytes (or 128 or 64, but why not bigger?).

You should have an independent set of RX/TX buffers for each UART.

Changing the period of your periodic timer ISR is not going to affect the problem with your original code.  Within your periodic ISR, your code is spending 7 milliseconds NOT reading the UART.  Your code is going to lose bytes regardless of the timer period.