Look the problem will most probably(Haven't tested especially for SFML but for 3D this is valid) be the fill rate of the GPU and the driver calls(draw calls). Any overdraw of pixels that have already been painted on is a waste and GPU's rasterizers are pretty slow for modern graphics. The vertex assembler, shader, etc. etc. is insanely fast and you must reach several millions vertexes before it becomes a problem. Though the rasterizer is starting to have a problem as soon as you reach the pixel amount of the max resolution. Some GPU's can't even handle the max resolution.(mine for instance can't, it just about manages)
So if you want to draw ~10 000 sprites on screen you will face two bottlenecks. The draw calls for each sprite and the pixel overdraw.
So what are your options? Well since SFML doesn't have a depth buffer you can't do a front to back render to remove the pixel overdraw so your stuck with that. What you can do is render static environment to in-memory textures and render those only once and such remove the overdraw from there. And then we have the draw calls. First step is to cull and only render stuff that is shown on the screen. But that won't be enough because you most probably will still be showing a lot of sprites at once on the screen. The solution here is Instancing but is only supported on later hardware(OpenGL 3+) but kind
Almighty Laurent have provided us with an alternative
Vertex arrays. If possible you can link the sprites together into one vertex array and render them with one draw call.
These things might be seen as pretty advanced but when it comes to optimizing the GPU it becomes pretty advanced ^^
Summary is more or less, limit your draw calls and the amount of pixels you render and your performance will go up.
If needed I can give the research and data and explanation for why these things are valid ^^
Though thumb of rule, never trust anything until you've tested it yourself. Always benchmark and profile everything when you are optimizing.