Welcome to the forum.
I;ve not used it myself, but according to the documentation PowerGrep understands the Perl and .NET style of regex patterns so the following should get you started at least. Try the pattern:
<!--\[if\x20gte\x20mso\x209\]>((?!<!\[endif\]-->).)*<!\[endif\]-->
with the 'singleline' (also called "dot matches newline" in some contexts) set and possibly with the 'ignore case' option set. The replacement string should be blank.
I'm not sure what you mean by "Sometimes the .... might begin again". If the "if"s can be nested, then the above won't work, but if you mean that the 'if-endif' sequence can appear multiple times in the same document then the pattern will work but you will need to do whatever withn PowerGrep to tell it to match multiple times.
The way this works is to first match the begining phrase (<!--\[if\x20gte\x20mso\x209\]>) where the spaces have been replaced with '\x20'. In some regexs you can use space characters but using '\x20' to represent a space makes the character and the number explicit (e.g. is " " 1, 2, 3 or 4 spaces?????). You can also use '\w' to represent a whitespace character but this would also include tabs and newlne characters - in this case that may be OK but only you can tell baxed on what is in the files.
The next part steps thorugh the next part of the text one character at a time and stops when it sees the ending phrase. The "(?!<!\[endif\]-->)" part is a negative lookahead which in interpreted as "from here, look forward and see if the next characters match this sub-pattern. If they do not (hence the 'negative' part of the name) then carry on; otherwise stop processing this group and move on". This is embedded in the group "( .)*" which tehchs the lookahead and then steps forward one character before repeating the whole match group test again. In this way it will match everything until it gets to the first occurrance of the eding character sequence where it will stop.
The last part simply matches the end character sequence.
In some patterns you will see the whole lookahead part replaced with ".*?" which is a non-greedy match of any character (but see the next comment) and relies on the part of the pattern that follows to limit the match. There have been wars fought over less, but I prefer the technique I've shown because it is extendable with arbitrarily complex subpatterns and is very explicit as to when to stop.
I've use the '.' (dot) regex operator which matches all characters except the newline character and this is controlled by the (badly named) 'singleline' option. A better name might be 'dot matches newline'. Basically, if the opton is not set, then the dot does not match a new line character and so will stop at the end of each line of text. If the option is set, then the newline character is matches and so the match can span multiple lines if necessary.
The pattern I've presented is the 'raw' pattern which is what is expected to be used by the regex engine. I don't know if this is acceptable to PowerGrep so you may need to add other things to it such as escape characters and delimiters. However, as PowerGrep is a stand-alone program, I would expect that it would accept the pattern just as I've shown it above.
You have not shown us what else surrounds the target text and so there may be other things in the text that will trip this pattern up.
Hope this helps
Susan