The simple solution to not using modulus is to maintain a tick-counter for each case and, when it triggers, reset it to 0.
An alternative is to keep the 'time' of the next trigger point, and increment this point when it is triggered. ie, if you want to fire every 10 ticks, compare the tick counter to 10, and when it fires, increment the trigger point variable to 20. This saves you having many counters that increment but at a cost of maintaining trigger values for each case.
Or you could have a single counter and a single trigger point that is re-calculated to reflect the next trigger time. ie if you have a trigger to fire every 10 ticks and another every 25 ticks, the trigger point would be changed to 10, 20, 25, 30 after each invocation. The cost here is passed to the time the trigger fires (which I assume is a reasonably lengthy operation itself)
(I've used these techniques myself, but usually for time-based delays where re-calculation of date/time values is more computationally intensive than an integer and the delay between ticks is relatively very long)
Now this may not be quicker than using modulus, the memory consumption might be enough to cause cache misses which is an order of magnitude greater than any FPU math operation. If you had many, many cases stored in an array then this is a likely outcome.
Of course, you might be able to use a better bit of maths to handle the modulus, and your CPU might be better or worse at calculating it. eg if your modulo value is a multiple of 2 you could use bit-shifting and masking to determine if a trigger point is reached, ie if you fire every 8 ticks, then the counter matches if the last 3 bits are 0 (ie 8 is 00001000, 16 is 00010000, 24 is 00011000 etc). Bit-masking is a very fast operation.