
<p class="has-drop-cap">I december 2010 lanserade Örebrotravet med idékläckaren Håkan ”Lillis” Olsson och Claes Broberg i spetsen ett nytt stort insatslopp för tvååringar i Sverige. Svampen såg sitt ljus och hade premiär året efter med två lopp, ett för vardera kön. Loppet har hela tiden även varit öppet för utlandsfödda tvååringar.<br>De två första åren handlade det alltså om två klasser, men sedan 2013 har en vinnare korats.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/feelnopain2210131-617x333.jpg" alt="" class="wp-image-367267"/><figcaption class="wp-element-caption">Daniel Wäjersten och Feel No Pain vid segern i Svampen 2022. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p>550.000 kronor väntar vinnaren av årets upplaga av Svampen. Det är det tredje högsta förstapriset i loppets historia. Bara fjolårsvinnaren <strong>Feel No Pain</strong> (e. Walner) och 2020 års etta <strong>Mi Ma Ohrtus</strong> (e. Jocose) har inkasserat större prischeckar: 600.000 respektive 558.000 kronor.<br><strong>Prisskala:</strong> 550.000-275.000-137.500-66.000-44.000-27.500 kr.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Den flitigaste tränaren i Svampen är Jägersros Tomas Malmqvist, som haft 14 tvååringar till start. Det har också bjudits på en hel del framgångar. Tre gånger har en Malmqvist-tränad häst segrat:</p>



<ul class="wp-block-list">
<li>2012 – Tumble Dust (e. Crazed)</li>



<li>2013 – Elton Attack (e. Gigant Neo)</li>



<li>2014 – Tunika (e. Zola Boko)</li>
</ul>



<p>I år saknas Malmqvist i startlistan och detsamma gäller den näst framgångsrikaste tränaren Per Nordström. Jägersrotränaren har vunnit loppet två gånger, med <strong>Denim Boko </strong>(e. Chocolatier) 2012 och <strong>Dixi Sisu</strong> (e. Ready Cash) 2015.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/erictheeel3-617x333.jpg" alt="" class="wp-image-449705"/><figcaption class="wp-element-caption">Tomas Malmqvist. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Jägersrotränarna dominerar i listan över de tidigare vinnarna och av 14 segrande tvååringar har sex tränats på just Skånebanan. Förutom Malmqvist och Nordström har även Joakim Lövgren tränat en vinnare i <strong>Executive Caviar</strong> (e. S.J.’s Caviar). Lövgren har en häst i årets lopp, nyförvärvet <strong>Cantal</strong> (e. Maharajah), som gjort två starter i Paul Hagoorts regi.</p>



<p>Björn Goop är bäst i klassen bland kuskarna med tre triumfer – <strong>Dairy Queen</strong> (e. Quite Easy), <strong>Tunika</strong> (e. Zola Boko) och <strong>Executive Caviar</strong> (e. S.J.’s Caviar) – medan Per Nordström räknat in två vinster.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Förutom Joakim Lövgren vet även Gävletränaren Fredrik Wallin vet hur man vinner loppet. 2019 slog hans toppsto <strong>Sayonara</strong> (e. Donato Hanover) till tillsammans med Carl Johan Jepson.<br>I år har Wallin dubbla chanser till en andra seger, då han plockar ut både Chapter One (e. Chapter Seven) och <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar). Duon tillhör de mest rutinerade i fältet med fyra respektive fem starter. Chapter One har en seger – i uttagningslopp till Breeders Course där hon stod över finalen – medan Matchmadeinheaven väntar på första vinsten.</p>



<p>Matchmadeinheavens mamma <strong>Inga In Heaven</strong> (e. Orlando Vici)1.11,2am/2.237.465 kr, vann visserligen bara tre lopp, men hade en fin tävlingskarriär med andraplatsen i Drottning Silvias Pokal som topp. Det tog fart redan som tvååring och i livets sjätte start slutade hon femma i Svampen 2015! Dottern Matchmadeinheaven gör sin sjätte start i livet i årets upplaga.</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/lamourpourblancareadam-617x333.jpg" alt="" class="wp-image-512954"/><figcaption class="wp-element-caption">Rick Ebbinge drog längsta strået med L&#8217;Amourpourblanca när hästen plockade ned Reijo Liljendahls Ronno i ett Breeders Crown-lopp på Solvalla. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">De tolv tvååringarna har hunnit 35 starter hittills i karriären, knappt tre starter per häst alltså. <strong>Matchmadeinheaven</strong> och Anders Svanstedts <strong>V.Bucks</strong> (e. Brillantissime) har varit flitigast med fem framträdanden vardera, medan <strong>L’Amourpourblanca</strong> (e. Face Time Bourbon) och USA-importen <strong>Ronno</strong> (e. Walner) bara gjort en start.</p>



<p>Då möttes hästarna dessutom, i ett Breeders Crown-lopp på Solvalla, där de först duellerade om ledningen och sedan gjorde upp om segern på upploppet. Ronno vann den första striden och anförde loppet, men L’Amourpourblanca tog hem den viktiga fighten och speedade förbi i sista stegen efter lucka 100 meter från mål från vinnarhålet.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Hittills i år har 120 tvååringar i svensk träning tävlat i Sverige och den som tjänat mest är Moa Thörngrens och Zeb Jonassons <strong>Ajson</strong> (e. S.J.’s Caviar), som slog in prischecken på hela 400.000 kronor i ASVT:s auktionslopp under Kriteriehelgen.<br>Vinstrikast är annars svenskfödde, men Paul Hagoort-tränade, <strong>O’Hara Boko</strong> (e. Robert Bi), som slog till i Breeders Course-finalen på Jägersro för drygt två veckor sedan med 700.000 kronor i förstapris.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/ajsonmal1-617x333.jpg" alt="" class="wp-image-509090"/><figcaption class="wp-element-caption">Ajson vann ASVT Trottex Auktionslopp med hela 400.000 kronor i segerpremie och han är en son till S.J.&#8217;s Caviar. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Vinstrikaste svensktränade tvååringar 2023</h2>



<p><em>Häst (far) – Tränare – Prispengar</em></p>



<ol class="wp-block-list">
<li><strong>Ajson</strong> (h e. S.J.’s Caviar) – Moa Thörngren, Solvalla – 440.000 kr</li>



<li><strong>Monster Wine</strong> (v e. Googoo Gaagaa) – Per Nordström, Jägersro – 375.000 kr</li>



<li><strong>Duncan Cowan</strong> (e. Walner) – Svante Båth, Solvalla – 352.000 kr</li>



<li><strong>Captiva</strong> (e. Walner) – Per Nordström, Jägersro – 280.000 kr</li>



<li><strong>Chapter One</strong> (e. Chapter Seven) – Fredrik Wallin, Gävle – 270.000 kr</li>
</ol>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Global Farm mönstrar två hästar i Svampen, Daniel Wäjersten-tränade <strong>Global</strong> <strong>Fearless</strong> (e. Booster Winner) och Viktor Lycks <strong>Global Forecast</strong> (e. Trixton). Den storsatsande uppfödaren har en triumf i loppet, då <strong>Global Adventure</strong> (e. S.J.’s Caviar) slog till för fem år sedan.<br>Svante Båth tränade vinnaren som kördes av Erik Adielsson. Segertiden var tangerat löpningsrekord, 1.13,3a/1.609 meter, en notering som delas med Marcus Lindgrens <strong>Maze Runner</strong> (e. G.H.Nemo) från 2017.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/01/nelnhansportr2-617x288.jpg" alt="Sulkysport, Travsport, Hans Nelén" class="wp-image-17811"/><figcaption class="wp-element-caption">Hans Nélen. Foto Mia Törnberg/Sulkysport

</figcaption></figure>



<p>Hans Neléns Global Farm kan även luta sig emot en seger som hästägare. Fjolårsvinnaren <strong>Feel No Pain</strong> (e. Walner) köptes på Menhammar Online-auktionen sommaren 2021 för prick en miljon kronor av Nelén och i Daniel Wäjerstens regi hade hon en stark tvååringssäsong, som förutom Svampensegern även innehöll segrar i Breeders Crown-lopp och försök till Svensk Uppfödningslöpning (sexa i finalen).</p>



<p>Global Forecasts mamma <strong>Global Mix</strong> (e. Cantab Hall), 1.13,8ak/429.500 kr, har sin andra startande avkomma i Svampen. <strong>Global Bookmaker</strong> (e. Broadway Hall) slutade trea i 2019 års upplaga.</p>



<p><a href="https://sulkysport.se/lycka-i-svampen/" target="_blank" rel="noreferrer noopener">––> Läs mer om Viktor Lyck och hans Global Forecast här!</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Fjorton vinnare har korats i Svampen och en avelshingst kan stoltsera med två vinnare. Det handlar om veteranen S.J.’s Caviar vars vars söner <strong>Executive Caviar</strong> och <strong>Global Adventure</strong> varit först över mållinjen.</p>



<p>S.J.’s Caviar finns representerad även i årets upplaga, då han är pappa till Fredrik Wallin-tränade <strong>Matchmadeinheaven</strong>.</p>



<p>Årets Svampen-fält bjuder på avkommor med tolv olika fäder.</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/v.bucks-617x333.jpg" alt="" class="wp-image-512961"/><figcaption class="wp-element-caption">V.Bucks och Anders Svanstedt. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">Sju av Svampenhästarna har sålts på auktion och en av dem till och med två gånger. Dyrast på svensk auktion är <strong>Our Brodde</strong> (e. Googoo Gaagaa), som hästägare hos danske tränaren Gordon Dahl ropade in för 650.000 kronor på Solvalla Yearling Sale förra året. Hästen skulle ha gjort sin tredje start i livet i Svampen, men Dahl har tvingats stryka honom på grund av feber.</p>



<p>Reijo Liljendahl åkte över Atlanten förra hösten och i Harrisburg i november hittade han hingsten <strong>Ronno</strong> (e. Walner) för 65.000 dollar.</p>



<p>Joakim Lövgrens <strong>Cantal</strong> (e. Maharajah) såldes först som ettåring för 100.000 kronor och bytte ägare igen på Åby Yearling &#038; Mixed Sales i höst för 360.000 kronor.</p>



<p>Mattias Djuse har agerat både köpare och säljare till Svampenhästar. Han är uppfödare till <strong>V.Bucks</strong> (e. Brillantissime), som bjöds ut på Kriterieauktionen ifjol och ropades in av Anders Svanstedt. Djuse slog själv till på samma auktion och köpte <strong>Pop The Cork</strong> (e. Perfect Spirit) för 40.000 kronor.<br>Hästarna möttes också i ASVT:s Auktionslopp under Kriterieveckan, där Pop The Cork var fyra och V.Bucks sexa.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/popthecork-617x333.jpg" alt="" class="wp-image-512963"/><figcaption class="wp-element-caption">Pop The Cork och Mattias Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Auktionspriser för Svampenhästarna</h2>



<p><em>Häst (far) – Auktion – Pris</em></p>



<ul class="wp-block-list">
<li><strong>Ronno</strong> (e. Walner) – Harrisburg – 65.000 dollar</li>



<li><strong>Our Brodde</strong> (e. Googoo Gaagaa) – Solvalla Yearling Sale – 650.000 kr</li>



<li><strong>Cantal</strong> (e. Maharajah) – Åby Yearling &#038; Mixed Sale – *360.000 kr</li>



<li><strong>Chapter One</strong> (e. Chapter Seven) – Åby Yearling Sale – 160.000 kr</li>



<li><strong>R.K.Fade</strong> (e. Readly Express) – Solvalla Yearling Sale – 125.000 kr</li>



<li><strong>V.Bucks</strong> (e. Brillantissime) – Kriterieauktionen – 110.000 kr</li>



<li><strong>Cantal</strong> (e. Maharajah) – Solvalla Yearling Sale – 100.000 kr</li>



<li><strong>Pop The Cork</strong> (e. Perfect Spirit) – Kriterieauktionen – 40.000 kr</li>
</ul>



<p><em>*Auktionspris som tvååring.</em></p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/melbawestwoodcjj231012gk-617x333.jpg" alt="" class="wp-image-509072"/><figcaption class="wp-element-caption">Mattias Djuse tränar tvååriga Melba Westwood som tillsammans med Carl Johan Jepson vann i Örebro. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">Mattias Djuse firar framgångar med både unghästar och äldre och i Svampen har Solvallatränaren en duo till start. <strong>Pop The Cork</strong> (e. Perfect Spirit) kommer från fjärdeplatsen i ASTV:s auktionslopp under Kriteriehelgen och väntar på första segern efter tre starter, medan <strong>Melba Westwood</strong> (e. Trixton) avlade maiden i sin andra start i ett tvååringslopp i just Örebro.</p>



<p>På avdelningen auktionslopp – fyra av Svampenhästarna möttes i Sweden International Yearling Sales Auktionslopp med en kvarts miljon kronor till vinnaren i slutet av september. Vinnaren <strong>Captiva</strong> (e. Walner) finns inte med i Svampen, men det gör både tvåan <strong>Chapter One</strong> (e. Chapter Seven), trean <strong>Cantal</strong> (e. Maharajah), sexan <strong>R.K.Face</strong> (e. Readly Express) och strukne <strong>Our Brodde</strong> (e. Googoo Gaagaa), som slutade oplacerad.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Tidigare vinnare av Svampen								</h3>
<div class="content">
<p><em>År/vinnare (far) – Kusk (tränare) – Segertid</em></p>
<ul class="wp-block-list">
<li>2011 <strong>Dreams Take Time</strong> (h e. Andover Andover) – Örjan Kihlström (Jim Oscarsson) – 1.15,5a</li>
<li>2011 <strong>Dairy Queen</strong> (s e. Quite Easy U.S.) – Björn Goop (Per Engblom) – 1.16,6a</li>
<li>2012 <strong>Tumble Dust</strong> (h e. Crazed) – Erik Adielsson (Tomas Malmqvist) 1.14,6a</li>
<li>2012 <strong>Denim Boko</strong> (s e. Chocolatier) – Per Nordström  – 1.14,0a</li>
<li>2013 <strong>Elton Attack</strong> (v e. Gigant Neo) – Jorma Kontio (Tomas Malmqvist) – 1.16,0a</li>
<li>2014 <strong>Tunika</strong> (s e. Zola Boko) – Björn Goop (Tomas Malmqvist) – 1.14,6a</li>
<li>2015 <strong>Dixi Sisu</strong> (s e. Ready Cash) – Per Nordström – 1.14,0a</li>
<li>2016 <strong>Executive Caviar</strong> (h e. S.J.’s Caviar) – Björn Goop (Joakim Lövgren)  – 1.14,3a</li>
<li>2017 <strong>Maze Runner</strong> (v e. G.H.Nemo) – Johnny Takter (Marcus Lindgren) – 1.13,3a</li>
<li>2018 <strong>Global Adventure</strong> (h e.  S.J.’s Caviar) – Erik Adielsson (Svante Båth) – 1.13,3a</li>
<li>2019 <strong>Sayonara</strong> (s e. Donato Hanover) – Carl Johan Jepson (Fredrik Wallin) – 1.14,8a</li>
<li>2020 <strong>Mi Ma Ohrtus</strong> (h e. Jocose) – Rikard N Skoglund (Joakim Elfving) – 1.14,2a</li>
<li>2021 <strong>Tetrick Wania</strong> (h e. Muscle Hill) – Riina Rekilä – 1.14,0a</li>
<li>2022 <strong>Feel No Pain</strong> (s e. Walner) – Daniel Wäjersten – 1.14,5a</li>
</ul>
<p><em>De två första åren kördes Svampen i två avdelningar, en för ston och en för hingstar/valacker.</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
