Refactoring code that is "running" fine, is the next biggest mistake that you can do. Especially when all you require is a 100+ line modification to get that bug fixed in the dirty way. The fact that it looks extremely ugly and that it could get worse when you try to hack a patch on top of a hack, still just not justify it. Simply because, it _is_ running fine no matter how fugly it looks. A refactor sure does put you back on the path to nirvana, but only after a painful bunch of sleepless nights.
If you brave it and go ahead with the refactor, the FUD that your subconscious generates while in the process is not even funny. As you do the next best design for world domination, your FUD-subconscious is silently calculating the broken parts of the application. And before you realize, your 'deliverable application' just became a 'still-in-development application' :-/ Not something that should happen when your deadline was yesterday. Slowly it becomes a war of reasoning between the 'FUD-subconscious' and the 'Optimist-subconscious'. As the pain increases, the damage caused by the refactor starts to out-weigh the pros. Thats the time when the FUD-subconscious starts pushing in ideas of abandoning the refactor and going on with the 100+ line fugliness. You might even apply it, reconsider, revert the fugliness and get back to refactoring, a couple of times.
All the while, silently reassuring yourself that this pain is not for nothing. That this pain is for more than just beautiful looking code. That this pain is to make sure you dont have to go through this again in the future. That this pain is actually for something useful. That once its done, it shall open up limitless possibilities. Whether those 'limitless possibilities' are required, only time can tell :-/ It is very likely that those 'limitless possibilities' would never be realized, ever.
Hmm.. Why then?