I assume that the sample text you have provided is ALL the text that is being processed by the regex in which case it works in my ".NET" based regex tester and I must admit that I can't see anything that would cause the Java regex class (as documented on the various web pages) to complain.
However there are a couple of things I do notice. You use the '.*' pattern twice and this is the basis of my comment about the sample being the only text being presented to the regex. What this will do is to grab all characters from the current position in the text to the end of the line (or string of the "singleline" option is on), because the '*' quantifier is greedy and tries to match as many characters as it can. It will then move on to the next part of the pattern and try to match that which, in general, will fail and so it starts to backtrack by releasing an already matched character and trying to match the following pattern again. It will continue to do this until it either finds a match or releases all of the characters (the "*" quantifier considers matching nothing to still be successful).
In your case the first '.*' will therefore find the last instance of the " <tr><td colspan=9><strong> " text which also happens to be the first/only instance in your sample text.
It then finds another '.*' and does the same process all over again, only this time it manages to retain the "08 Feb 2010" characters.
Two things: generally you don't need to account for characters before any text that you are really interested in; and you should use the '.*' pattern with great care.
The first point means that almost any pattern that starts with '.*' is wrong (in my opinion) because you almost never need to know ALL of the characters before the last instance of the following pattern character sequence in the string. If you start your pattern with '<tr><td colspan=9>' etc., then the regex will try to match this pattern against the string. Given your test string it will fail because the first character in the string is a space. Therefore its default action is to skip over a character and try the match again - and in this example it will succeed.
The second point has already really been covered above. However the way to avoid it has not. I generally use one of 2 methods to avoid the problems this pattern causes. The first is to make it non-greedy as in '.*?' (where this allowed - Java does according to the documentation I've found). What this does it to try to match a character and then check whatever follows in the pattern to see if that succeeds - if so then the pattern carries on; if not then it matches another character and repeats the process. In this way it only matches as few characters as it needs to to match the following part of the pattern.
The other technique is to only match what you really mean. This can also be approached in two ways. If you want to match any alphanumeric character sequence then use something like '\w+' as this puts into the pattern just what you want. In your case this is a bit tricky as you want to match spaces within the date part but not the space and other characters afterwards. Therefore you could turn this around to be '[^<]+' which will match everything up to but not including the next "<" character. In other situations you may want to match to the next "</strong>" character sequence (again following your example string) in which case something like '((?!</strong>).)*' will work.
Regex patterns work best when you have really thought about exactly what you want (or don;t want) to match at any point and code that explicitly into your pattern. There certainly are cases where '.*' is exactly what you want (as in the case of a "//" form of single line comment where you want to grab everything from there to the end of the line - '//.*' with the 'singleline' ot "dot matches newline" option off) but I find it is generally misused and a source of error.
Perhaps if you show us the code snippet you are using and a full example of the text (if you have only provided a small sample) then we can help you further.
Susan