My bad, I should have looked more closely to the actual code and what's been going on, and what I said wasn't true.
When you fetch the related entity with a prefetch path, it sets the flag that the entity is already fetched. If there's no related entity found, it still does that, setting the related entity to null.
When you then read the property, it will first check whether the flag whether the fetch already happened (it did, so it has the value true) and if true, it will skip lazy loading altogether and simply return the value of the property (which is null). If it's false (which is the case when no prefetch path fetch took place and you read the property for the first time), it will perform the lazy loading procedure which will simply instantiate an instance of the related entity type with the value of the FK field(s) which will either read the data into the entity instance or leave it new (if nothing's there). If the flag 'returns new if not found' for that property is true, the entity instance will be returned, otherwise null will be returned.
The flag in question which controls the 'return null if not found' is for lazy loading. It was a design choice in the very first release to return a new entity regardless whether a related entity was there or not to avoid null ref exceptions, however this turned out to be a mistake (I still regret it to this day), and we switched it off (so it returns null properly, like it should) however that would break lots of code, so we added a setting for this: the flags which control the returns new if not found which are controllable from the designer's code generation settings.
So I now see what your problem is: you have to work with code which always assumes there's an entity, however this goes wrong when you add prefetch paths, as a non-found entity fetch then returns null, not a new entity.
It's a problematic situation, because changing this is a breaking change so we won't do that. However it doesn't solve your problem as well. I don't know what the situation is with the code you have to work with, whether there's a way to find the situations where this could cause a problem or not.
To me the situation to return null or a new entity isn't really that different: if I do:
var c = myOrder.Customer;
I have to check whether c is a real entity instance: either by testing for null, or by checking whether it's new / entity state is new. If your code doesn't do that either, it's buggy either way. Could you check that please, if the checks for Isnew are there? If so, you can find them and alter them to test for null as well.