For time complexity, it partly depends on where you want to improve the time. You could consider a FIFO where each record has the price and the timestamp and also something else: the largest price over every item that is as/more recent. This would mean an $O(n)$ operation for each batch of items that is inserted, but it would improve the time for fetching the maximum price, since you could peek at the front of the line, and pull off a few obsolete items (older than an hour) until you find an item no more than an hour old, and then the max price in that item is the value you want.
Or you could make each record contain the max price over all that is at least as old. In this case, to retrieve the max price over hour, it is an $O(1)$ operation if no old items need to be removed from the FIFO, but otherwise all the old items need to be purged and the max prices recomputed in $O(n)$.
But maybe what you want is a specialized B tree, in which each node contains as an extra field the largest price in the whole subtree. Whenever the B tree is restructured, all subtrees that are altered will require those fields to be recomputed. In the worst case, all deletions are happening at one end of the tree and all insertions at another... so I don't know if some of the extra balancing work of the tree is significant. After deleting an obsolete item, it would take $O(\log n)$ operations to update the nodes above it. Once a tree is purged of data more than an hour old (and all new data is added), only the tree root needs to be consulted to determine the maximum price in this case.
In all these instances, the best scheme with respect to time might depend on how frequently that price question needs to be answered compared to how frequently new data needs to be input.
I think the space complexities for these approaches are $O(n)$. With regard to space-saving you might think of having a data structure for each period of 10 minutes like so: 1:00-1:09; 1:10-1:19; etc. Then each price record only needs to contain a timestamp relative to the 10 minute threshold. If you precision is 1 sec, then each record only needs to distinguish which of 600 seconds the price is mamixum over. If it takes a second or more to compute the maximum anyway, then it should be precise enough to eliminate data that is 3600 +/- 1 second old.
The time precision is important. Is it close enough to count things minute by minute? If so, then you only need one record for each minute, and you can update the last minute's record with any new data if there are multiple data coming in for that minute. This will affect your storage by a significant factor, but this factor would only be $O(1)$.