My take on this (as SW engineer): consistency. Pick one and stick with it, at least within a given project. Do not pay too much attention to "potential performance problems" with either one of them. If that really is your biggest concern, you've already done an extra-ordinarily good job. Most of the times, the increment of a loop variable will make no difference.
As far as performance optimization goes: always measure, never guess. Do not optimize prematurely, it may even have an adverse effect (you'd be surprised how smart compilers actually can be!). Optimize on macroscopic level (pick appropriate algorithms and data structures), taking the boundary conditions into account; bubble sort, while scaling terribly, might actually be fast enough if you know you're only ever dealing with a hand-ful of elements. Profile, profile, profile. And then profile some more. Pick the hotspots and remove them. Then profile again to verify improvements.
More often than not, the clarity of the code should be your number 1 priority. It should be immediately obvious what the code is doing and why. When reading the code, the moment you have to stop and think what the hell is going on, its structure is bad and needs to be changed. Never waste the time of the person reading your code -- this is very rude. Which closes the loop: consistency. If you use post-increment here and here and here, and at one place you pre-increment, what you're basically doing is forcing the reader of the code to think about the difference and why that would be important. Time and concentration budget that could've been spent more productively, going to waste.
This may sound a bit harsh, but I've seen many programs written by brilliant mathematicians and physicists, that are a nightmare to read and understand, let alone adapt. If you think about it, the "adapting" part is the main trait of the software. If it cannot be easily changed, it is no longer "soft", and thus misses its point. Please, don't be clever.