
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Uranium - the misunderstood Trump Trade</h3><h4>22 July 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>I will do everything in my power to unite the Democratic Party — and unite our nation — to defeat Donald Trump and his extreme Project 2025 agenda. We have 107 days until Election Day. Together, we will fight. And together, we will win.<em>"</em></p><p>Kamala Harris Vice President of the United States of America</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='uranium-the-misunderstood-trump-trade' href='/Content/Downloads/ARP/ARP240722.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/669e814e418dab45624ecc97_iStock-1483917321_705x414.jpg#243;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Performance of baskets in the ARP Megatrend Fund</strong><br />
<em>Note: 27/06/2024 &ndash; 19/07/2024<br />
Source: Absolute Return Partners</em></p>
' data-image='/Content/Images/66bb4de0e09c6283db729ba2_669e8561cfea64f63d17ff34_Picture3.png#330;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#330;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#330;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#330;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The Trump Trade</h4><p>As we all know, Biden delivered a dreadful performance in the televised debate with Donald Trump on the 27th of June. From one moment to the next, investors became so convinced Trump will prevail in November that they began to structure their portfolios accordingly &ndash; the so-called Trump Trade.</p>

<p>--image--</p>

<p>Out went everything related to the green agenda, and in came fossil fuels and other industries believed to benefit from a Trump victory. In our portfolio, as you can see in Exhibit 1 above, the Carbon basket suffered. So did Green Materials and Uranium, and the latter is what this paper is about. In the following, I will argue that classifying uranium as a Trump Trade is a mistake of gigantic proportions which investors should take advantage of.</p>

<p>Trump may or may not win in November but, as you will see below, demand for uranium will be unaffected by a Trump victory. On the other hand, should Kamala Harris prevail (assuming she is nominated), green stocks will almost certainly be firmly back on the agenda. In other words, in our book, uranium is a win-win.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: Worldwide nuclear electricity production</strong><br />
<em>Source: World Nuclear Association</em></p>
' data-image='/Content/Images/66bb4de1e09c6283db729bda_669e82e85d784848ce44910f_Picture4.png#331;slide-image;;' data-alt-text2= '<p><strong>Exhibit 3: Nuclear electricity generation by country </strong><br />
<em>Source: World Nuclear Association</em></p>
' data-image2= '/Content/Images/66bb4de0e09c6283db729b9a_669e834262f861db528ab89e_Picture5.png#331;slide-image2;;' data-alt-text3= '<p><strong>Exhibit 4: Nuclear reactors under construction, by country </strong><br />
<em>Source: World Nuclear Association</em></p>
' data-image3= '/Content/Images/66bb4de1e09c6283db729bad_669e83752f57a8c5a8bfdfec_Picture6.png#331;slide-image3;;' data-image4= '/Content/Images/66bb4de1e09c6283db729baa_669e83a344763d1505a3693b_Picture7.png#331;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The demand outlook</h4><p>When the commercial nuclear industry began in earnest in the 1960s, there were clear boundaries between East and West. Today, the nuclear industry is one of the most globalised of all industries. A reactor under construction in Asia may have components supplied by South Korean, Canadian, Japanese, French, German, US or Russian companies, and uranium from Australia or Namibia may end up in a reactor in the UAE, having been enriched in the Netherlands and de-converted in the UK.</p>

<p>There are about 440 nuclear reactors in operation worldwide. As you can see in Exhibit 2, the 1970s, 1980s and 1990s made up the golden period of nuclear energy, and the industry grew rapidly; however, since Chernobyl and Fukushima, the industry has not grown at all. Today, nuclear accounts for about 10% of all electricity generation.</p>

<p>--image--</p>

<p>According to <a href="https://world-nuclear.org/information-library/current-and-future-generation/nuclear-power-in-the-world-today">World Nuclear Association</a>, the aggregate capacity of the 440 reactors in operation worldwide is 396,324 MWe. Adding to that number, 62 nuclear reactors with an additional 65,159 MWe of capacity are currently under construction, i.e. capacity will grow 16-17% between now and 2030.</p>

<p>At present, the US nuclear power industry is the undisputed world leader. As you can see in Exhibit 3 below, nuclear electricity generation in the US is more than that of #2 (China) and #3 (France) <em>combined</em>. This has led many investors to assume that, to invest in uranium, the US investment case must be robust. <em>Nothing could be further from the truth!</em></p>

<p>Nuclear reactors use a highly predictable amount of fuel (uranium) every day, reason being that the existing technology doesn&rsquo;t allow power plants to adjust the output according to demand. It is either 0% or 100% of capacity every day. Nuclear power plants are only shut down during maintenance or if they are decommissioned. Take for example 2022. That year, due to maintenance, US nuclear reactors ran with a capacity factor of 92.6%. (source: <a href="https://css.umich.edu/publications/factsheets/energy/nuclear-energy-factsheet">Nuclear Energy Factsheet</a>). In other words, one can calculate, almost to the second decimal point, demand from existing nuclear power plants.</p>

<p>For research analysts trying to predict the uranium price going forward, it is all about demand from new power plants vis-&agrave;-vis expected supply. How electricity demand is affected by the economy is irrelevant, and that is why the number of reactors under construction is the most important number (Exhibit 4).</p>

<p>As mentioned earlier, according to <a href="https://world-nuclear.org/information-library/current-and-future-generation/nuclear-power-in-the-world-today">World Nuclear Association</a>, there are currently 62 nuclear reactors under construction worldwide. In preparation for this paper, I have looked at different sources and, admittedly, the number varies slightly from source to source. According to some, there are only 57 reactors under construction. Others argue that the number is 59, whereas World Nuclear Association says 62. I wondered why and looked into it. It turned out that not all reactors currently under construction but delayed vis-&agrave;-vis original plans are included by everybody.</p>

<p>--image2--</p>

<p>Whatever the exact number, as you can see in Exhibit 4, about half of all reactors under construction are being built in China, not a single one in North America and only a couple in the EU. In other words, the US and the EU are virtually irrelevant to the demand story. Almost 100% of the anticipated growth in demand for uranium over the next 6-7 years will come from other parts of the world.</p>

<p>--image3--</p>

<p>Precisely how dominant China will become is evident if you look at Exhibit 5 below. As you can see, China committed in earnest to nuclear in the 1990s and have since built over 50 reactors. With another 28 under construction and many more in the planning process, China will soon become the driving force in the nuclear industry.</p>

<p>--image4--</p>

<p>However, China is far from self-sufficient as far as uranium is concerned (like the US), which brings me back to the opening lines of this paper &ndash; despite various frictions between East and West, the nuclear industry is a truly global industry. The need to feed their reactors with the chosen fuel (in most cases, uranium) force the global powers to put their disagreements aside and deal with each other.</p>

<p>One last point re demand: power plants buy enriched uranium for consumption, and they buy it for warehousing. It is not unusual for industry buyers to keep two years of consumption in stock. However, US nuclear power plants have, in recent years, allowed their inventories to sink to all-time lows in anticipation of lower prices. At some point, they&rsquo;ll have to restock.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 6: Largest identified uranium resource </strong><br />
<em>Source: </em><a href="https://css.umich.edu/publications/factsheets/energy/nuclear-energy-factsheet"><em>University of Michigan</em></a></p>
' data-image='/Content/Images/66bb4de0e09c6283db729b9f_669e83f59509ff78829da305_Picture8.png#332;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#332;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#332;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#332;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The supply outlook    </h4><p>The fuel going into almost all nuclear reactors is so-called enriched uranium &ndash; uranium with a high concentration of U-235 isotopes which are easier to split in the reactor. When uranium is mined, it contains less than 1% U-235.</p>

<p>Only 1% of all uranium available at a reasonable cost is found in the U.S. The largest deposits are in Australia (28%), Kazakhstan (13%), Canada (10%), Russia (8%), and Namibia (8%) (Exhibit 6). However, uranium mining is a far bigger industry in Kazakhstan and Canada than it is in Australia, making those two countries #1 and #2 respectively in terms of output.</p>

<p>--image--</p>

<p>The US &ndash; the country with most nuclear reactors &ndash; purchased 18,370 tonnes of uranium in 2022 &ndash; mostly from Canada (27%), Kazakhstan (25%), Russia (12%) and Uzbekistan (11%). Globally, nuclear power reactors required 62,496 tonnes of uranium in 2021.</p>

<p>It takes on average 7-8 years from a new mining programme is launched until the enriched uranium can be fed into a reactor somewhere in the world, and that is precisely why the demand/supply outlook is so promising. Until about 18 months ago, not a single new mining project had been launched since Fukushima, i.e., we know that we are at least 5-6 years away from a meaningful increase in global supplies.</p>

<p>&nbsp;</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#333;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#333;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#333;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#333;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Risks</h4><p>By far the biggest risk associated with uranium is another Chernobyl or Fukushima. Few people died from radiation in those two incidents (1 in Fukushima) and 30 in Chernobyl), but the psychological damage was immense and by far the most important reason why Americans and Europeans are still reluctant to embrace nuclear energy despite it having a far safer track record than other energy forms.</p>

<p>In that context, it is also worth noting that modern nuclear reactors are based on a construction methodology developed in the 1990s and the 2000s, and not a single accident has happened to reactors based on the new technology. Not one.</p>

<p>Allow me to make one last point. It is about public opinion, and how it drives political decisions. As pointed out earlier, growth in nuclear power is rapidly shifting from DM to EM countries. Most DM countries are mature democracies where public opinion weighs heavily on the political decision process.</p>

<p>Most EM countries are different in that respect. Let&rsquo;s assume China runs into a problem like Fukushima. We know what happened in Japan post-Fukushima. I do not think the Chinese political leadership would face the same problem, should something similar happen in China. In other words, as more and more nuclear energy is EM-based, the risk of the public opinion turning against nuclear energy becomes less and less pronounced.</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#334;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#334;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#334;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#334;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Conclusion</h4><p>Uranium is not a Trump Trade. The American impact on uranium demand is far too one-sided for that to be the case. Having said that, it does not imply that American investors cannot impact the uranium price &ndash; not at all. Uranium used to be in demand almost exclusively from industry buyers, but that has changed the last couple of years. As the uranium price skyrocketed, more and more financial buyers (of which we are one) decided to get on the bandwagon, but financial buyers have added plenty of volatility to the price.</p>

<p>As it becomes increasingly clear that the global uranium market will be under-supplied for a number of years, the price will most likely go higher &ndash; potentially a lot higher &ndash; but volatility is also likely to be higher than it has been historically, and that is a function of more widespread financial participation.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>22 July 2024</strong></p></div></div></div>