Stax, 19 bytes

Ç╛√êΣ%,╖FP╚`=Lh←⌡·ƒ

Run and debug it

Retina 0.8.2, 21 bytes

iT`Io`AOIiaoi`^.+?p

Try it online! Transliterates letters up to and including the first p, although the z and p aren't in the transliteration section so aren't affected. The first O is quoted because it normally expands to 13567 and the second o is quoted because it too is magic; in the first part of the transliteration it expands to the other string. The resulting transliteration is therefore from IAOIiaoi to AOIiaoi then removing the duplicate source letters results in IAOiao to AOIaoi.

Japt, 22 20 bytes

-2 bytes thanks to Oliver

r"%v+"_d`i¬iao¯`pu}"

Try it online!

JavaScript (Node.js),  69  63 bytes

s=>Buffer(s).map(c=>s|c%4<1?s=c:c&1?c-[6,-14,,,8][c%16%5]:c)+''

Try it online!

How?

We process the input string $s$ character by character.

We reuse $s$ as a flag: as soon as a numeric value is stored in it, we know that we must not update anything else.

We use the following properties to identify the characters at the beginning of the string:

• The ASCII codes of p (112) and P (80) are multiples of $4$.


• The ASCII codes of z (122) and Z (90) are even, but not multiples of $4$.


• The ASCII codes of the vowels a (97), A (65), i (105), I (73), o (111) and O (79) are odd.

To turn a vowel with ASCII code $c$ into its counterpart, we use the following hash function:

$$n=(cbmod 16)bmod 5$$

and use $n$ to pick a value that must be subtracted from or added to $c$ from a lookup table.

Commented

s =>                  // s = input string

  Buffer(s)           // convert it to a Buffer of ASCII codes

  .map(c =>           // for each ASCII code c in s:

    s |               //   if s is numeric

    c % 4 < 1 ?       //   or c is either 'p' or 'P':

      s = c           //     turn s into a numeric value and yield c

    :                 //   else:

      c & 1 ?         //     if c is a vowel:

        c -           //       update c to either c - 6 ('o' -> 'i'), c + 14 ('a' -> 'o')

        [6, -14,,, 8] //       or c - 8 ('i' -> 'a')

        [c % 16 % 5]  //       small hash function to convert from ASCII code to index

      :               //     else (c is either 'z' or 'Z'):

        c             //       let it unchanged

  ) + ''              // end of map(); coerce the Buffer back to a string

C (gcc),  81 76  74 bytes

Similar to my JS answer, with another hash function. Outputs by modifying the input string.

x,c;f(char*s){for(x=1;c=*s;)*s++=c%4<x?x=c:c&1?c+"zx16"[c*3%11%3]&127:c;}

Try it online!

Commented

x,                          // x is used to test if we've reached a 'p' or a 'P'

c;                          // c is the current character

f(char * s) {               // f = function taking the input string s

  for(x = 1; c = *s;)       // start with x = 1; for each character c in s:

    *s++ =                  //   update the current character and advance the pointer:

      c % 4 < x ?           //     if c is 'p' or 'P' or x was raised beyond 3:

        x = c               //       store c in x and let the character unchanged

      :                     //     else:

        c & 1 ?             //       if c is a vowel:

          c +               //         update it to the next vowel in the sequence

          "zx16"           //         by adding either 122, 120 or 14

          [c * 3 % 11 % 3]  //         according to the result of the hash function:

                            //         'a'/'A' -> 2, 'i'/'I' -> 1, 'o'/'O' -> 0

          & 127             //         and forcing it back into [0..127]

        :                   //       else (c is either 'z' or 'Z'):

          c;                //         let it unchanged

}                           // implicit end of for(); end of function

Perl 6, 41 33 bytes

{S:i{.+?p}=$/~~tr/iaoIAO/aoiAOI/}

Try it online!

Simple case-insensitive substitution to shift the vowel section.

C# (Visual C# Interactive Compiler), 79 bytes

n=>n.Select(c=>(char)((c+"aoi")[("iao".IndexOf((char)(c|32))+1)%4]&~(c&32^32)))

Try it online!

Explanation

We first map each character named c to either itself or appropriate character out of "aoi". The reason we prepend c is to avoid checking for a IndexOutOfBoundsException and so c has it's regular value if it's not an a, o, or i. Next we apply a bitwise AND between ~(c&32^32) and the result of the last step, which preserves the case of c.

Perl 5, 31 bytes

s/.+?p/$&=~y,iaoIAO,aoiAOI,r/ei

TIO

R, 110 bytes

Attempting to do this with a vector input was way too frustrating, so this function will take an input of one string.

function(a){p='(?i)^(z+)([aio]+)(p+.*)';sub(p,paste0('\1',chartr('aioAIO','oaiOAI',sub(p,'\2',a)),'\3'),a)}

Try it online!

Ruby, 40 bytes

$_[$&]=$&.tr"IAOiao","AOIaoi"if/z+.+?p/i

Try it online!

05AB1E (legacy), 22 bytes

l'pkIg‚£ć…iaoDÀ‚Du+`‡ì

Try it online or verify all test cases.

Can definitely be golfed a bit more..

Uses the legacy version of 05AB1E instead of the Elixir rewrite, because + merges fields in same-length lists, whereas the new version would need a pair-zip-join ‚øJ instead.

Explanation:

l                       # Lowercase the (implicit) input-string

                        #  i.e. "ZipPeroni" → "zipperoni"

 'pk                   '# Get the index of the first "p"

                        #  i.e. "zipperoni" → 2

    Ig‚                 # Pair it with the length of the entire input-string

                        #  i.e. 2 and "zipperoni" → [2,9]

       £                # Split the (implicit) input-string into parts of that size

                        #  i.e. "ZipPeroni" and [2,9] → ["Zi","pPeroni"]

        ć               # Extract head: push the head and remainder separately to the stack

                        #  i.e. ["Zi","pPeroni"] → ["pPeroni"] and "Zi"

         …iao           # Push string "iao"

             DÀ         # Duplicate, and rotate it once towards the left: "aoi"

               ‚        # Pair them up: ["iao","aoi"]

                Du      # Duplicate and transform it to uppercase: ["IAO","AOI"]

                  +     # Python-style merge them together: ["iaoIAO","aoiAOI"]

                   `    # Push both strings to the stack

                    ‡   # Transliterate; replacing all characters at the same indices

                        #  i.e. "Zi", "iaoIAO" and "aoiAOI" → "Za"

                     ì  # Prepend it to the remainder (and output implicitly)

                        #  i.e. ["pPeroni"] and "Za" → ["ZapPeroni"]