Memory Efficiency

The general rule to efficiency is to do as little as possible, as few times as possible. In your case, setting the maximum health to the same thing every frame is not only pointlessly ineffectient, but it's also unclear as to why. Rather that the "when this, do that" you have repetitve checks which isn't as logical, and logic, in coding, is everything.
I would change the actual events where Counter is changed to 1 or 2, rather than check it as a response. What you're doing appears to be:
On A, set counter to x. On counter is x, set max health to y.
rather than:
On A, set counter to x, and set max health to y.
or even:
On A, set max health to y.
(A being the original events where you change Counter)

You could also look into use of global values, as counters are a lot more memory and not so easy to keep track of. There's only one global value no matter what you have on the frame, but you can have several copies of a counter which will conflict with each other.

Doing one action when event loops still reads and tests the conditions, so you'd only be saving resources for the actions. If you must always do a check for the amount of maximum health, it's probably best to just do:

Always = set max health to 100+(CounterValue*50)

You can also have it be this way with renamed global values, as Phi suggests:

Always = set max health to InitialHealth+(HealthUpgrade*HealthMultiplier)

InitialHealth = 100
HealthUpgrade = Your counter value - 1, 2, 3, etc.
HealthMultiplier = How much health is added per upgrade.

For this kind of thing, probably almost no resources are wasted anyway. But since they pile up eventually, it's good you're trying to optimise it from the start.

A small detail I want to mention is that lot of people mistakenly think that an action is always heavier than a condition. You can often end up in a scenario where the conditions that checks if the action should be performed are heavier than just performing the action on every frame.

Setting the maximum health is so light that you don't have to worry about it. In cases where it's heavy, you should benchmark the different options.

Well, I offered that solution judging by what you asked for. There's no way I can predict details you haven't yet mentioned (: You can include sine functions in the max health formula if you want to have variations between each interval. You can pretty much get any result you want with the appropriate expression. Also, I find it much more advantageous and efficient to do this kind of thing in one action instead of using several events. What is OCD in this context, by the way?

I think it's a lot about balancing it right. When it comes to tasks that are very CPU friendly, I always go for the solution which results in the cleanest and most understandable events even if it turns out to be slightly heavier. When it really matters, I benchmark a few solutions by running a fastloop that carries out the same operation tons of times per frame and check what framerate I get.