PHP, 61 bytes

-1 byte thanks to @Arnauld

-1 byte because i replaced the "\n" sequence with a literal linebreak

for($i=9;$i<20;)echo date('H:i:s',(++$i%11*4+6)*981.819)."

";

This is a translation of the JS answer by @Arnauld https://codegolf.stackexchange.com/a/278472/127414

Try it online!

Bash + common linux utilities, 45

jot -w@ 11 1963.5 41236.5|date -uf- +%I:%M:%S

Try it online!

JavaScript (V8), 67 bytes

-4 thanks to Lucenaposition
-1 thanks to l4m2

This version requires a locale in the expected format.

for(i=9;i<20;)print((new Date((++i%11*4+6)*981819)+0).slice(16,24))

Try it online!

JavaScript (V8), 72 bytes

This version doesn't depend on the locale.

for(i=9;i<20;)print(new Date((++i%11*4+6)*981819).toJSON().slice(11,19))

Try it online!

Retina 0.8.2, 87 bytes

25$*
11
$'¶
G`11
1
21600$*
(1{39600})+(1{660})*(1{11})*1*
$#1:$#2:$#3
\b\d\b
0$&
O`¶.+

Try it online! Explanation: Vaguely ported from my Charcoal answer.

25$*
11
$'¶
G`11

List the odd numbers from 25 down to 3.

1
21600$*

Multiply them all by 21600.

(1{39600})+(1{660})*(1{11})*1*
$#1:$#2:$#3

Divide them by 11, then also divmod them by 60 twice. (It turns out to be slightly golfier to do this in one replacement, as it avoids problems with integer division and converting zero to decimal.)

\b\d\b
0$&

Left-pad single digits with a zero.

O`¶.+

Sort all lines after the first.

Zsh, 74 bytes

zmodload zsh/datetime
repeat t=1962.8,11 strftime %I:%M:%S $[t-=3927.3,~t]

Attempt This Online!

Here $t is one off of the opposite of the correct timestamp, which ~t corrects and forces an integer.

Interesting that this outgolfs the equivalent eval expression by a few bytes.

zmodload zsh/datetime       # load strftime command
repeat t=-1963.8,11         # abuse the argument to repeat being an arithmetic context to set $t
                            # (this doesn't save any bytes but it's a cool detail)
    strftime %I:%M:%S $[t-=3927.3,~t]  # ~t is needed to force an integer

Google Sheets, 69 bytes

=index(substitute(text((row(1:11)-1)/22+1/44.01,"hh:mm:ssa/p"),"a",))

Iterates the sequence starting at the dateserial value 1/44.01 = 0.02272210861, i.e., the time value 0:32:43.190, and increments by 1 / 22 ten times. Renders the resulting dateserial as hh:mm:ss with a one-letter AM/PM marker, and finally removes the marker.

Ungolfed:

=index(substitute(
  text(
    sequence(11, 1, "0:32:43.190", 1 / 22), 
    "hh:mm:ssa/p"
  ),
  "a", ""
))

Python, 84 80 79 bytes

-4 bytes thanks to Jonathan Allan -1 byte thanks to Lucenaposition

lambda:[time.ctime(1963.5-~i*3927.3)[11:19]for i in[10,*range(10)]]
import time

Attempt This Online!

1963.7 is the unix timestamp 1970-01-01T01:32:43.5 and 3927.3 is an approximation of \$\frac{12}{11}\$ hours in seconds.

Python, 71 bytes

-4 thanks @Lucenaposition

lambda:11*"%02x:%02x:%02x\n"%(*b"2C
8C8IT2\0\0'T	!!I'",)

Attempt This Online!

Previously:

Python, 75 bytes

lambda:11*"%02x:%02x:%02x\n"%(*b"2C
8C8IT2\x00\x00'T	!!I'",)

Attempt This Online!

Returns a single newline separated string (with a trailing newline). Contains non printables.

Python 2, 75 74 73 70 bytes

import time
i=23;exec'print time.ctime(i*1963.64)[11:19];i=i%22+2;'*11

Try it online!

Python, 72 bytes

A touch from each of corvus_192's, Lucenaposition's, and Albert.Lang's existing Python answers.

lambda:[time.ctime(i*216/.11)[11:19]for i in b"C/13579;=?A"]
import time

Attempt This Online!

Wolfram Language (Mathematica), 75 bytes

RotateRight@Array[TextString@TimeObject[6+12#/11]&,11,-4]~StringRiffle~"\n"

Try it online! The builtins have long names but they behave the right way for this challenge.

x86-64 machine code, 50 bytes

6A 06 5E 89 F1 69 D1 16 4C 63 00 92 F7 E6 92 04 30 AA 83 F6 0C B0 3A 85 F0 7A F0 AA 84 D2 75 EB C6 47 FF 0A 80 C1 0C 79 DC 88 2F 66 C7 47 9D 31 32 C3

Try it online!

Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes in RDI a memory address at which to place the result, as a null-terminated byte string.

In assembly:

f:  push 6; pop rsi # Set ESI to 6. ESI will hold a multiplier.
    mov ecx, esi    # Set ECX also to 6. ECX will hold a counter.
                    # (Using the same value saves a byte here.)
n:  imul edx, ecx, 6507542  # Set EDX to 6507542 times ECX.
        # This value as a fraction of 2^32 rounds down to
        #  the desired time as a fraction of a sexagesimal 1:00:00:00.
        # (The hour part is not actually sexagesimal, but is treated
        #  as sexagesimal for uniformity to shorten the code.)
r:  xchg eax, edx   # Exchange registers, putting the fraction in EAX.
    mul esi         # Multiply the fraction in EAX by ESI.
                    #  The low part of the result goes into EAX
                    #  and the high part goes into EDX.
    xchg eax, edx   # Exchange EAX and EDX.
    add al, '0'     # Add the character code of '0' to AL
                    # (the low byte of EAX, which holds the high part)
                    #  to produce the digit to be output.
    stosb           # Write it to the string, advancing the pointer.
    xor esi, 12     # Exclusive-or ESI with 12, changing it
                    #  from 6 to 10 or vice versa (alternating).
    mov al, 0x3A    # Set AL to 0x3A, the character code of ':'.
    test eax, esi   # Calculate the AND of EAX and ESI and set flags.
    jpe r           # Jump if the sum of the low 8 bits is even,
                    #  which is true when ESI=10 but not when ESI=6.
    stosb           # Write ':' to the string, advancing the pointer.
    test dl, dl     # Set flags based on the low byte of EDX.
         # 6507542 was chosen so that EDX initially has two 2 factors. 
         #  Each multiplication by 6 or 10 adds one 2 factor,
         #  so that after six multiplications, the low byte is 0.
    jnz r           # Jump if it is nonzero.
    mov BYTE PTR [rdi - 1], '\n'    # Replace the ':' with '\n'.
    add cl, 12      # Add 12 to the low byte of ECX (the counter).
    jns n           # Jump if the result's high bit is 0.
                    #  The high bit is 1 after 11 iterations, at 138.
    mov [rdi], ch   # Add a null terminator to the string from CH
                    # (the second-lowest byte of ECX).
    mov WORD PTR [rdi - 99], 0x3231
                    # Fix the first time by replacing 00 with 12.
    ret             # Return.

05AB1E, 23 bytes

11L·>Á11/Ž≠µ*60вT‰J':ý»

Port of @JonathanAllan's Jelly answer, so make sure to upvote that answer as well!

Try it online or Try it online with step-by-step debug lines.

Explanation:

11L                      # Push a list in the range [1,11]
   ·                     # Double each
    >                    # Increase each by 1
     Á                   # Rotate once towards the right
      11/                # Divide each by 11
         Ž≠µ*            # Multiply each by compressed integer 21600
             60в         # Convert each to a base-60 list, ignoring their decimals
                T‰J      # Add leading 0s if necessary:
                T‰       #  Divmod each inner-most value by 10
                  J      #  Join each inner-most pair together
                   ':ý  '# Join each inner triplet together with ":"-delimiter
                      »  # Join the list of strings by newlines
                         # (after which the result is output implicitly)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why Ž≠µ is 21600.

Ruby, 60 bytes

Port of corvus_192's Python answer

->{[10,*0..9].map{|i|Time.at(1963.7-~i*3927.27).to_s[11,8]}}

Try it online!

zsh + GNU coreutils, 46 bytes

eval 'date +%r -d@$[1963.7+3927.27*'{0..10}]\;

Try it online!

Requires a locale that doesn't use AM/PM, for example en_DK.utf8.

APL+WIN, 51 bytes

¯1⊖'G<Z9:99:99>' ⎕fmt 100⊥(3⍴60)⊤⌊(.5+⍳11)×43200÷11

Try it online! Thanks to Dyalog Classic

Jelly, 27 bytes

11Ḥ€‘ṙ-÷×⁽RcḞb60+³DḊ€€j€”:Y

A full program that accepts no input and prints the times.

Try it online!

How?

11Ḥ€‘ṙ-÷×⁽RcḞb60+³DḊ€€j€”:Y - Main Link: no arguments
11                          - set the left argument to eleven
  Ḥ€                        - double each
    ‘                       - add one
     ṙ-                     - rotate right one
                                -> [23,3,5,7,9,11,13,15,17,19,21]
       ÷                    - divide {these} by {11}
        ×⁽Rc                - multiply {those} by 21600
            Ḟ               - floor {those}
             b60            - convert {those} to base sixty
                +³          - add 100 to {those}
                  D         - convert {those} to base ten
                   Ḋ€€      - dequeue {those} (removing the leading ones)
                      j€”:  - join each with ':'
                          Y - join with newline characters
                            - implicit print

Charcoal, 30 bytes

Ｅ⊕χ⪫Ｅ↨÷ײ¹⁶⁰⁰⊕⊗∨ι⊕χ⊕χ⁶⁰﹪%02dλ:

Try it online! Link is to verbose version of code. Explanation:

  χ                             Predefined variable `10`
 ⊕                              Incremented
Ｅ                               Map over implicit range
                ι               Current value
               ∨                Logical Or
                  χ             Predefined variable `10`
                 ⊕              Incremented
              ⊗                 Doubled
             ⊕                  Incremented
       ×                        Multiplied by
        ²¹⁶⁰⁰                   Literal integer `21600`
      ÷                         Integer divided by
                    χ           Predefined variable `10`
                   ⊕            Incremented
     ↨                          Convert to base
                     ⁶⁰         Literal integer `60`
    Ｅ                           Map over parts
                            λ   Current part
                       ﹪        Python format using
                        %02d    Literal string `%02d`
   ⪫                         :  Join with `:`s
                                Implicitly print

Incremented(c) is used instead of 11 because you can't abut the latter without a separator.

Uiua 0.15.0-dev.2, 47 bytes ^SBCS

≡/$"_:_"⬚@0°⋕⍉⌊[⍜⊢⋅12⊃÷◿⟜⊃÷◿60]×+0.5⇡11÷₁₁43200

Try on Uiua Pad!

A full program that returns an array of 11 strings.

Explanation

×+0.5⇡11÷₁₁43200
        ÷₁₁43200    # 43200/11, number of seconds between times
 +0.5⇡11            # range [0.5, 1.5, ... , 10.5]
×                   # multiply, desired times in seconds

[⍜⊢⋅12⊃÷◿⟜⊃÷◿60]
[                 ] # do this, then join into an array
           ⟜⊃÷◿60  # divmod with 60, leaving 60 on stack
       ⊃÷◿         # divmod again
 ⍜⊢⋅12             # replace the first 0 with 12

≡/$"_:_"⬚@0°⋕⍉⌊   
                ⌊   # floor all values, truncating seconds
              ⍉    # transpose array
        ⬚@0°⋕      # stringify values, filling empty spots with 0s
≡/$"_:_"            # join each row with colons