
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Healthcare in Election Years - A Hot Potato?</h3><h4>05 January 2024</h4><div class='category-icon'>Opinions</div><div class='article-page-content__container__left__summary'><p><em>"</em>US healthcare is always a political hot potato, and volatility is expected to rise as the November elections approach.<em>"</em></p><p>Alliance Bernstein</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='healthcare-in-election-years' href='/Content/Downloads/ARP/ARP240105.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/6597fcd6b763cef013de947d_iStock-479515172_705x414.jpg#232;article-main-image;705;414' /></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#386;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#386;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#386;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#386;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why this paper?</h4><p>Recently, I wrote a megatrend paper on changing demographics, where I highlighted healthcare as a long-term winner. While I am not about to change that view, I forgot to mention (as pointed out by a subscriber) that healthcare stocks often struggle in US presidential election years.</p>

<p>Politicians, in their eagerness to &lsquo;bribe&rsquo; voters, make all sorts of promises, and one of the most frequent ones is a pledge to reduce the cost of healthcare to Joe Public, should they get elected. Although such promises have almost always turned out to be no more than thin air, investors get anxious and healthcare stocks begin to underperform. This paper is an attempt to assess whether this is something to be concerned about, as we enter another election year.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Election year returns of various S&amp;P 500 sectors, 1998-2019 (ex. 2008)</strong><br />
<em>Source: </em><a href="https://scholars.unh.edu/cgi/viewcontent.cgi?article=1531&amp;context=honors"><em>University of New Hampshire</em></a></p>
' data-image='/Content/Images/6597fda2bee00838176fc2b0_Picture2.png#387;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: US healthcare stocks price/forward earnings vs. S&amp;P 500</strong><br />
<em>Source: </em><a href="https://www.alliancebernstein.com/library/Should-Investors-Avoid-US-Healthcare-Stocks-in-an-Election-Year.htm"><em>alliancebernstein.com</em></a></p>
' data-image2= '/Content/Images/6597fded70deb1de6e8500dd_Picture3.png#387;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#387;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#387;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The outcome in US presidential election years since 1998 </h4><div>
<p>The US stock market tends to do poorly in presidential election years relative to non-election years. In election years between 1998 and 2019 (ex. 2008), the S&amp;P 500 has underperformed the S&amp;P 500 in non-election years by 381 basis points. That number increases to 1,260 basis points if 2008 is included. Why exclude 2008? 2008 was an election year, but it was also the year of much drama, as the Great Financial Crisis climaxed. It therefore makes sense to exclude 2008 from an analysis like this, as my conclusions would be distorted by including it. When taking a closer look at the numbers, it is noticeable how consistent they are, i.e. one can fairly safely conclude that election years tend to be more challenging for investors than non-election years.</p>
</div>

<div>
<div>
<p>Now to healthcare. In election years between 1998 and 2019 (ex. 2008), US healthcare stocks have underperformed the S&amp;P 500 by 570 basis points. &nbsp;Adding to that, as you can see in Exhibit 1 below, healthcare is the only US industry that has delivered a negative return <em>on average</em> in election years &ndash; -0.25% to be precise.</p>

<p>--image--</p>

<p>Presidential candidates <em>always </em>promise to cut healthcare expenditures. &nbsp;Historically, Democratic candidates have outgunned Republican candidates on such undertakings but, more recently, candidates from both parties have been guilty of making such empty promises. A classic pledge has been to replace the existing private insurance model with a single-payer insurance system &ndash; essentially Medicare for all. Another promise that has frequently popped up is stricter controls with drug pricing (see later re the Inflation Reduction Act).</p>

<p>The net impact of all of this has been a tendency of (most) healthcare stocks to underperform in election years and, in that respect, HMOs and Big Pharma stand out &ndash; HMOs because of the pledge to convert to Medicare for all and Big Pharma because of the undertaking to regulate drug pricing.</p>

<p>Before Biden, the two most recent Democratic presidents were Clinton (from 1993 to 2000) and Obama (from 2009 to 2016). They both made loads of healthcare-related promises before moving into the White House, but most of those promises fizzled out. However, as you can see in Exhibit 2, in both instances, the negative impact on healthcare was significant before the tide turned again.</p>

<p>--image2--</p>

<p>&nbsp;</p>
</div>
</div>
</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#388;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#388;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#388;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#388;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What to expect in 2024</h4><p>When calculating US healthcare expenditures as a % of GDP, costs are hovering around 17-18% &ndash; dramatically higher than similar costs in Europe and Asia. I fully expect that to become a theme in the months to come, and I expect the usual amount of nonsensical promises to be made by candidates of both parties, desperate to catch the attention of the electorate. For that reason, I expect healthcare stocks <em>on average</em> to underperform the S&amp;P 500 between now and election day.</p>

<p>That said, healthcare companies that offer a solution to this problem &ndash; i.e. companies which can contribute to lowering expenditures &ndash; are likely to outperform those companies that benefit from the system as it is. Big Pharma and HMOs are likely to end up amongst the losers. Healthcare technology and biotechnology companies, on the other hand, could both outperform, as they tend to lower healthcare costs.</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#389;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#389;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#389;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#389;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Who will move into the White House and what does that mean?</h4><p>Trump is, in my opinion, the more likely candidate to become the next tenant of the White House but is facing (at least) two hurdles. <em>If </em>the Democrats were willing to bite the bullet and find a younger and more inspiring candidate to take the country forward, they could still win in November, but they are not very likely to bite that bullet.</p>

<p>The other obstacle facing Trump is if one of the (many) ongoing legal cases against him would make him unelectable across the nation, but the probability of that is even lower than the Democrats finding an alternative to Biden. I therefore conclude that we are most likely in for an other four years with Trump in charge.</p>

<p>From an investment point-of-view, that is actually not so bad. Trump is <em>very </em>unlikely to put roadblocks up in front of the healthcare industry, so my gut feeling is that 2024 will present some attractive buying opportunities in both Big Pharma and HMOs. Having said that, my forecast would change <em>instantly</em>, if one of the two obstacles I have just referred to would become a real issue.</p>

<p>In that context, I should also stress that with the pressure on Biden likely to rise as we approach election day, it is not at all unthinkable that he will also start to make silly promises. &nbsp;Given how close the race currently is, that could have a rather dramatic impact &ndash; on healthcare stocks but also on the election outcome.</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#390;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#390;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#390;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#390;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The Inflation Reduction Act</h4><p>Before I wrap this up, I should also mention the Inflation Reduction Act (IRA) which was passed by Congress in August 2022. Before the new law was passed, Big Pharma almost always held on their blockbuster drugs for as long as they could. Now, blockbuster drugs for the elderly will have their prices negotiated with the federal government.</p>

<p>It is expected that this is going to alter Big Pharma&rsquo;s focus. Going forward, in order to control pricing, they will probably pay more attention to drugs for younger cohorts, e.g. weight-loss drugs. That is another reason Big Pharma could come under pressure, as we approach the start date of the new pricing system (2026). That said, it could also mean healthcare perform differently this year than in other election years. Maybe the bad news is already priced in?</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#391;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#391;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#391;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#391;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>A few final words</h4><p>In summary, I conclude that the most conservative investors should probably stay clear of healthcare in 2024. &nbsp;If you wish to own healthcare, focus on those companies that provide a solution to the problem, And, finally, 2024 should offer plenty of long/short opportunities for more opportunistic investors.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>05 January 2024</strong></p></div></div></div>