data structure admitting top items with prefix
You can achieve $O(\log n)$ time insert, $O(\log n)$ time delete, $O(n)$ space,  and $O(m \log m + \log n)$ time search by augmenting the trie.

Store in each leaf the weight of the corresponding item.  Also, at each internal node, add a field with a pointer to the leaf of maximum weight that's reachable from that node.

It's easy to see how to perform insertion in $O(\log n)$ time, and it's easy to see why this still uses only $O(n)$ space.

Search for the top $m$ items with a certain prefix can be done in $O(m \log m + \log n)$ time.  First, find the node $x$ corresponding to that prefix.  Use that node to identify the first item of the output (the highest-weight item with that prefix).  Next, look at the children $y_1,\dots,y_k$ of node $x$, and for each, look at the highest-weight item with that prefix.  Add these $k$ nodes to a priority queue, keyed on the weight of the corresponding item.  Extract the highest-weight item from the queue; that's the second item of the output.  Look at the children of the node you just extracted, and add them to the queue.  Repeat until you have output $m$ items; in each iteration, you extract the node of highest weight from the priority queue, output the corresponding item, and add the children of that node to the priority queue.  Remove duplicates as you go.  Stop once you've output $m$ items.  You do $O(\log n)$ time to find the first node corresponding to the prefix, and then each subsequent iteration takes $O(\log m)$ time (since operations on a priority queue of size $O(m)$ can be done in $O(\log m)$ time), and you do $m$ iterations, for a total running time of $O(\log n + m \log m)$.

Deletion can be done in $O(\log n)$ time.  To delete an item, traverse the trie to find that item.  Then, update each node that you visited during that traversal.  To update a node $x$, if the maximum-weight leaf under $x$ is the the item you're deleting, check the children of $x$ to find the next-highest-weight leaf under $x$, and update $x$.  This does $O(1)$ work per node you traverse, and the traversal visits $O(\log n)$ nodes, so the total time for deletion is $O(\log n)$ time.