
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>The US Senate Bans Imports of Enriched Uranium from Russia</h3><h4>01 May 2024</h4><div class='category-icon'>Opinions</div><div class='article-page-content__container__left__summary'><p><em>"</em>This is a national security priority as dependence on Russian sources of uranium creates risk to the US economy and the civil nuclear industry that has been further strained by Russia’s war in Ukraine. Without action, Russia will continue its hold on the global uranium market to the detriment of US allies and partners.<em>"</em></p><p>The White House</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='the-us-senate-bans-imports-of-enriched-uranium-from-russia' href='/Content/Downloads/ARP/ARP240501.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/663206e1409e7c4438e0259e_iStock-1226809275_705x414.jpg#238;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Suppliers of enriched uranium to US electric utilities</strong><br />
<em>Sources: Bloomberg, US Energy Information Administration</em></p>
' data-image='/Content/Images/663208854c5b583861fe1dcf_Picture2.png#357;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#357;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#357;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#357;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The latest</h4><p>The US Senate voted yesterday evening to ban imports of enriched uranium from Russia. The proposed bill was already passed by the House of Representatives late last year and now only requires Joe Biden&rsquo;s signature to become law. I would consider that a formality, though, given recent statements from the White House.</p>

<p>Imports from Russia account for about one-quarter of all enriched uranium used in US utilities (Exhibit 1), and the new law was passed <em>after </em>the markets closed last night. Therefore, this is not yet in prices.</p>

<p>--image--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#358;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#358;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#358;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#358;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The implications</h4><p>Yesterday, uranium equities endured one of the worst one-day sell-offs we have experienced in recent times. Our uranium basket was down about 3.4%, but I would expect those losses to be erased quite quickly on the back of this news.</p>

<p>You should be aware that certain waivers are in place in the new law to ensure that US electric utilities don&rsquo;t run out of fuel. Those waivers will be in place until 27/12/2027, i.e. for almost four years. Having said that, utilities must prove that they have approached suppliers all over the world and got a no, <em>and </em>that they are about to run out of stock (which nuclear utilities never are). If they can&rsquo;t prove that, they cannot take delivery &ndash; even on legacy contracts.</p>

<p>Policy makers have emphasized that these waivers are not in place for utilities to save money (Russian enriched uranium is typically cheaper than enriched uranium from elsewhere) but to ensure adequate deliveries. In the dark days of yesterday, Canadian and US uranium producers were left for dead by nuclear utility companies, eager to save on costs by switching to the cheaper Russian uranium. Consequently, up to 80% of all staff were fired in the uranium mining industry. Now is pay-back time. At least that is my read from reading between the lines of what has been said and done.</p>

<p>The big question now is what sort of response Russia will come with. One possibility is that they introduce an <em>immediate </em>export ban. Should they do that, prices will only go higher. Regardless of the Russian response, over the months (and years) to come, I expect a rising market with higher highs and higher lows but with plenty of volatility along the way. The uranium spot price is hovering around $90 this morning. In the last major bull market (pre-Fukushima), the price reached $140. I believe that level will be surpassed in this bull market.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>01 May 2024</strong></p></div></div></div>