There are many problems where we know of an efficient randomized algorithm, and we don't know of any deterministic algorithm that we can prove is efficient. However, this may reflect shortcomings in our ability to prove things about complexity rather than any fundamental difference.
Based on your comment, it appears you meant to ask whether there exists any problem where there is an efficient randomized algorithm, and we can prove there is no deterministic algorithm of comparable efficiency. I don't know of any such problem.
Indeed, there are reasonable grounds to suspect that such problems might be unlikely to exist. Heuristically, the existence of such a problem would likely mean that secure cryptography is impossible. That seems like a rather implausible outcome.
What's the connection, you ask? Well, consider any randomized algorithm $A$ that solves some problem efficiently. It relies upon random coins: random bits obtained from a true-random source. Now suppose we take a cryptographic-quality pseudorandom generator, and replace the true-random source with the output of the pseudorandom generator. Call the resulting algorithm $A'$. Note that $A'$ is a deterministic algorithm and its running time is approximately the same as $A$.
Also, if the cryptographic PRNG is secure, heuristically we should expect $A'$ to be a good algorithm if $A$ is:
For instance, if $A$ is a Las Vegas algorithm (it always outputs the correct answer, and terminates rapidly with high probability), then $A'$ will be a pretty good deterministic algorithm (always outputs the correct answer, and terminates rapidly for most inputs).
As another example, if $A'$ is a Monte Carlo algorithm (deterministic running time, and outputs the correct answer with probability at least $1-\varepsilon$), then $A$ will be a pretty good deterministic algorithm (deterministic running time, and outputs the correct answer on a fraction $1-\varepsilon$ of all inputs).
Therefore, if the cryptographic PRNG is secure and there is an efficient randomized algorithm, you get a deterministic algorithm that is pretty good. Now there are many constructions of cryptographic PRNGs that are guaranteed to be secure if certain cryptographic assumptions hold. In practice, those cryptographic assumptions are widely believed: at least, secure commerce and transactions rely upon them being true, so we're apparently willing to bet large sums of money that secure cryptography exists. The only way this transformation can fail is if cryptographic PRNG don't exist, which in turn implies secure cryptography is impossible. While we don't have any proof that this isn't the case, it seems like an unlikely outcome.
Details of the construction: Here's how $A'$ works. On input $x$, it derives a seed for the cryptographic PRNG as a function of $x$ (e.g., by hashing $x$), and then simulates $A(x)$, using the output of the cryptographic PRNG as the coins for $A$. For instance, a specific instantiation would be to set $k=\text{SHA256}(x)$, then use $k$ as the seed for AES256 in counter mode, or some other cryptographic PRNG. We can prove the above statements under the random oracle model.
If you're unhappy with the idea that $A'$ might output incorrect results on some small fraction of inputs, that can be addressed. If you repeat $A'$ multiple times and take a majority vote, the error probability decreases exponentially fast in the number of iterations. So, by iterating a constant number of times, you can get the error probability $\varepsilon$ to be below $1/2^{256}$, which means the chances that you run across an input $x$ where the algorithm outputs the wrong answer are vanishingly small (less than the chances of getting struck by lightning multiple times in a row). Moreover, with the construction I gave above, the chances that an adversary can even find an input $x$ where $A'$ gives the wrong answer can be made very small, as that would require breaking the security of the SHA256 hash. (Technically, this requires the random oracle model to justify, so it means that $A$ must be chosen to be "independent" of SHA256 and not hardcode in it calculations that are related to SHA256, but almost all real-world algorithms will satisfy that requirement.)
If you want a stronger theoretical basis, you can iterate $A$ $\Theta(n)$ times, and get the error probability to be below $1/2^n$, where $n$ is the length of the input $x$. Now the fraction of $n$-bit inputs where $A'$ gives an incorrect answer is strictly less than $1/2^n$. But there are only $2^n$ possible $n$-bit inputs, and on each one $A$ is either correct or incorrect, so it follows that there is no input where $A'$ is incorrect: $A'$ is correct on all inputs, and this holds unconditionally. If $A$ runs in time $t(n)$, then $A'$ runs in time $\Theta(n \cdot t(n))$, so $A'$ is a bit slower than $A$ but not too much slower. This is the content of Adleman's proof that BPP is contained in P/poly. For practical purposes this is probably overkill, but if you like clean proofs that avoid cryptographic assumptions or if you approach this from a theoretician's perspective then you might like this version better.
For more details on the latter theoretical considerations and additional problems where we know of an efficient randomized algorithm but we don't know of any deterministic algorithm that we can prove is efficient, see https://cstheory.stackexchange.com/q/31195/5038
In summary: For any problem where we know an efficient randomized algorithm, we also know of a deterministic algorithm that seems likely to be efficient in practice -- but at present we don't know how to prove that it is efficient. One possible interpretation is that we're just not very good at proving stuff about algorithms.
