The first question to ask is "what is a time standard?" We take them for granted so deeply that we oft don't even think about what they mean.
A time standard typically provides two fundamental concepts, a duration and a time point. The intuitive meanings for those worlds are quite reasonable. A time point is, well, a single point in time. The time points are ordered, so we can say "time point A occurred before time point B". A duration is the time that passes between two time points, which is a scalar value with units of time. With duration we can say "time point A occurred 3 seconds before time point B."*
Time points, by their nature, are very hard to pin down. They're a little on the ephemeral side. To solve this, we pick one privileged time point, the "epoch" for the system, and we refer to all time points with respect to this one. So we might pick time point A to be our epoch, and say "time point B occurred 3 seconds after point A." If we also say "time point C occurred 4 seconds after time point A," we can do simple subtraction to say "time point C occurred 1 second after time point B."
So for our time system, we need two key things. We need a way of measuring the duration between time points, and we need a privileged "epoch" time point. It turns out that this is a challenge, even without FTL. If you do a google search for time standards, you come across all sorts of interesting ones. The history is fascinating enough to work with.
Universal time is a time standard based on the "solar time" at 0 degrees longitude. This is the prime meridian, itself an arbitrary line developed by the British between 1721 and 1851. It is "special" because everyone agreed to let it be special. We all agreed to call it 0 degrees longitude (well... mostly). It defines an epoch (time point 0) of Julian date 2541545.0, itself an arbitrary line in the sand made in 1583 which was literally chosen because its epoch (4713BC) was before any historical record! Talk about arbitrary!
There were a few variants. UT0 was based on measurements of distant quasars and such, but it did not handle polar motion correctly, so it was deprecated for UT1. UT1 is still technically in use, but it has a key limitation because it's time scale is dependent on the motion of the Earth, and that motion is slowly changing. Thus, we developed UTC, which is an atomic time scale (meaning the definitions of durations are defined via atomic clocks) which is kept within 0.9 seconds of UT1 by adding leap seconds.
Now there's a lot of people who don't like leap seconds, so we have other time standards which do not have them. TAI has no leap seconds, so it slowly drifts away from UTC (It is currently exactly 36 seconds ahead of UTC). TAI is a great reference source for your system because it went through growing pains. In the 1970s, they realized that gravitational time dilation was causing the different clocks (at different altitudes) to go at different rates. To resolve this, we re-defined TAI to be corrected such that all atomic clocks appeared to be at mean sea level (slowing down TAI by about a trillionth!).
TAI also has an even more pathological friend, Barycentric Coordinate Time (TCB). TCB accounts for movement of the solar system by applying corrections to put the "clock" at the barycenter of our solar system. It is also corrected to offset any gravitational effects. These effects are small, but they add up to about 490 milliseconds every year, which is quite a lot for atomic clock people!
So we've seen the solutions that have been done with real time systems, and they show how you would probably do it in your FTL system.
- Assign an epoch - This can be anywhere/anytime in the universe, all that matters is that people agree upon it.
- Assign a unit of time - This should be well defined at the location you used for your epoch, and it should be possible to calculate correction factors for elsewhere (just like we do for TAI or TCB)
Your correction factors are going to be more complicated with FTL, because you're going to need to sidestep general relativity without violating causality (if you violate causality, all bets on "time" are off). However, they'll just be correction factors.
And, along AnoE's solution, you could continuously update your correction factors if you can receive a time stamp from the source of your epoch (a.k.a. throwing a clock through a wormhole).
* This exact formalization is used in the
<chrono> library of C++, a popular programming language. I find it to be one of the better ways to formalize time, so I use it outside of programming.