Is it better to separate a big query into multiple smaller queries?
I am going to disagree on large and complicated queries with datagod here. I see these only as problems if they are disorganized. Performance-wise, these are almost always better because the planner has much more freedom in how to go about retrieving the information. However, large queries do need to be written with maintainability in mind. In general, I have found that simple, well-structured SQL to be easy to debug even when a single query goes on for 200+ lines. This is because usually you have a pretty good idea of what kind of problem you are dealing with so there are only a few areas in the query that you have to check.
The maintenance problems, IME, come in when the structure of SQL breaks down. Long, complex queries in subselects impairs readability and troubleshooting, as do inline views, and both of these should be avoided in long queries. Instead, use VIEWs if you can (note if you are on MySQL, views do not perform all that well, but on most other db's they do), and use common table expressions where those don't work (MySQL doesn't support these btw).
Long complex queries work pretty well both from a maintainability and performance case where you keep your where clauses simple, and where you do as much as you can with joins instead of subselects. The goal is to make it so that "records aren't showing up" gives you a few very specific places in the query to check (is it getting dropped in a join or filtered out in a where clause?) and so the maintenance team can actually maintain things.
Regarding scalability, keep in mind that the more flexibility the planner has, that's a good thing too....
Edit: You mention this is MySQL, so views are unlikely to perform that well and CTE's are out of the question. Additionally the example given is not particularly long or complex so that's no problem.
As somebody who has to support/cleanup these large and complicated queries, I would say it is far better to break them apart into several small easy to understand chunks. It is not necessarily better from a performance point of view, but you are at least giving SQL a better chance to come up with a good query plan.
Make life easier on the people that follow you, and they will say good things about you. Make it hard on them and they will curse you.
My 2 cents on the 2 keywords query-performance and scalability:
Query-Performance: SQL Server parallelism already does a very good job breaking down queries into multi-threaded searches so I'm not sure how much of a query-performance improvement you'll see by doing it for SQL Server. You will have to look at the execution plan to see how much of a degree of parallelism you get when you execute it however and compare results both ways. If you end up having to use a query hint to get the same or better performance, then IMO it's not worth it as the query hint might not be optimal later.
Scalability: Reading the queries might be easier as datagod stated, and breaking it down into separate queries makes sense if you can use your new queries in other areas too, but if you're not going to use them for other calls as well, then it'll be even more stored procs to manage for 1 task, and IMO wouldn't contribute any to scalability.