In nearly every game I've worked with, multiple systems are involved and each has their own ownership.
A common pattern (under various names) I've seen in all the big games I've worked on is to have a store, proxy, cache, and loader. The store serves as the hub, the controller, the thing many code bases call a "manager" (although I hate that name). The Proxy is what most people act on and it is what the code thinks of as the actual resource, this is what would be called a Sprite class or Texture class or Model class or AudioClip class or whatever. The cache decides how items are actually loaded in memory, decides what is loaded and helps with loading resources over time so the system doesn't block execution. The loader is what pulls the resources in at any time, and might have different ways of loading data out of multiple types of files, or monitoring file changes, or streaming across networks, etc.
Some set of code requests GetWhatever() from the store. The store create a proxy and sends it over to the the cache for data. The cache might point it to live data or to a placeholder object, returns a proxy object filled with some valid data, the proxy object gets returned to the main system. The gameplay code doesn't know (nor does it care) what is inside the proxy object; it is told the object is a Sprite and as far as it cares it is a fully functional sprite. In the background the cache uses a placeholder object, such as an alpha-ed out single pixel sprite in release build or a big red square in the debug build, and eventually the loader loads the resource and the placeholder is replaced with the actual object. This also allows multiple instances to share the same data because the cache can decide to share the data among as many systems as they want.
The rendering system works with the store to figure out all the instances that are active. The Store owns all the Proxy objects, it knows how many instances of objects are around, and controls the lifetime of when they are created and destroyed. The rendering system works with the store -- in this case a sprite store -- to draw all the sprites that need to be drawn.
There are naturally many more ways to do it, but this one works extremely well.