
<p class="has-drop-cap wp-block-paragraph">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>



<p class="wp-block-paragraph">På lördag bjuds det näst högsta förstapriset i loppets historia när lördagens vinnare tar hem 595.000 kronor. Bara 2022 års Svampenetta <strong>Feel No Pain</strong> (e. Walner) och Daniel Wäjersten har fått en större prischeck, 600.000 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">S<strong>ayonara</strong> (e. Donato Hanover) för fem år sedan och <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar) ifjol. Fredrik Wallin vet hur man gör för att vinna Svampen och i år rustar Gävletränaren med en duo.</p>



<p class="wp-block-paragraph"><strong>Global Got It All</strong> (e. Walner) har inlett tävlingskarriären prickfritt med två segrar på lika många starter, där tränaren själv satt i sulkyn i debuten på Axevalla. Nu lämnar han. över tömmarna till Claes Sjöström.<br>Fredrik kände även på stallets andra Svampenhäst i tävlingsdebuten. <strong>Pure Athena</strong> (e. Bar Hopping) var med i årets första tvååringslopp på svensk mark när hon slutade tvåa i premiären på Solvalla den 1 augusti. Då slutade hon tvåa bakom norskfödda <strong>Catchagaga Volo</strong> (e. Googoo Gaagaa) med galopp på vägen.</p>



<p class="wp-block-paragraph">Totalt har Wallin har åtta starthästar i Svampen tidigare och förutom vinnarna kan noteras <strong>Immortal Docs</strong> (e. Brilliantissime) tredjeplats 2022 och 2015 års femma <strong>Inga In Heaven</strong> (e. Orlando Vici) – mor till fjolårsvinnaren Matchmadeinheaven!</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/11/dayornightinheat-617x333.jpg" alt="trav, travsport, sulkysport, vincennes, frankrike, vintermeetinget" class="wp-image-33410"/><figcaption class="wp-element-caption">Day Or Night In. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Två gånger har även Per Nordström vunnit loppet, med <strong>Denim Boko </strong>(e. Chocolatier) 2012 och <strong>Dixi Sisu</strong> (e. Ready Cash) 2015. <br>Medan hans tidigare vinnare varit ston provar nu Jägersrotränaren med en hingst. <strong>Nightlife In</strong> kommer ur pappa Day Or Night In:s första kull och har inlett fläckfritt med två segrar på lika många starter.<br>– Han har alla bitar på plats den här hästen och har hela tiden varit en lovande talang som skött uppträningen på bästa sätt, sade Per Nordström efter debutsegern i Eskilstuna för en dryg månad sedan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/nightlifeinpnheatgk-617x333.jpg" alt="" class="wp-image-648685"/><figcaption class="wp-element-caption">Nightlife In och Per Nordström. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Svenskfödde avelshingsten <strong>Day Or Night In</strong> (e. Muscle Hill), 1.10,2ak*/5.256.538 kr, har sina första tvååringar på tävlingsbanan och 20 hästar finns i svenska kullen född 2022.<br>Day Or Night In klev fram i rampljuset i andra halvan av fyraåringssäsongen och tredjeplatsen i Derbyt följdes upp med andrapris i Criterium Continental på Vincennes. Senare vann Day Or Night In Prix Jean-Rene Gougeon i Paris. I Sverige har han tagit hem dubbla upplagor av L.C. Peterson-Broddas Minneslöpning och Kalmarsundspokalen.<br>Day Or Night In tränades hela karriären av Johan Untersteiner och gjorde 56 starter (17-8-4).</p>



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



<p class="has-drop-cap wp-block-paragraph">Första kullen tvååringar på tävlingsbanan har också Robert Berghs storstjärna <strong>Power</strong> (e. Googoo Gaagaa), 1.09,9am/12.010.376 kr. Året efter att han vunnit Europaderbyts final på Vincennes klev Power in i avelsboxen och blev fulltecknad direkt. Hans första kull född 2022 innehåller 104 svenskfödda travare och av dem har sju hunnit visa upp sig hittills som tvååringar.<br>Bäst hittills är <strong>Cala Karamell</strong>, 1.16,0ak/136.299 kr, som vunnit en av tre starter och aldrig varit sämre än trea. Vunnit lopp har även <strong>Venom</strong> gjort.</p>



<p class="wp-block-paragraph">Powers hopp i Svampen är Tomas Pettersson-tränade <strong>Vamos</strong>, som kommer från fjärdeplatsen i ASVT:s Auktionslopp på Solvall förra veckan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/powerrb-617x333.jpg" alt="" class="wp-image-461972"/><figcaption class="wp-element-caption">Power och Robert Bergh. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">På pappa Powers meritlista finns även seger i Svenskt Travkriterium, Svenskt Mästerskap och vinst i Prix de Croix (€100.000) på Vincennes. Han har även deltagit i Prix d’Amérique och slutat fyra i Pris de France (€400.000).</p>



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



<p class="has-drop-cap wp-block-paragraph">Den flitigaste tränaren i Svampen är Jägersrokollegan Tomas Malmqvist, som haft 15 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 class="wp-block-paragraph">I år mönstrar Malmqvist stoet <strong>Sassy But Classy</strong> (e. Maharajah), som varit femma och sexa i livets två starter, i försök-final i Breeders Course.</p>



<p class="wp-block-paragraph">Jägersrotränarna dominerar i listan över de tidigare vinnarna och av 15 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).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/01/elfvingjoakimportr-617x333.jpg" alt="" class="wp-image-58848"/><figcaption class="wp-element-caption">Joakim Elfving. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Rutin att vinna Svampen finns hos fler av tränarna bakom årets hästar. Förutom trion Wallin, Nordström och Malmqvist har ytterligare två svenskar i årets fält tidigare tränat fram en vinnare i loppet.</p>



<p class="wp-block-paragraph">Joakim Elfving tog sin första stora seger som tränare med <strong>Mi Ma Ohrtus</strong> (e. Jocose) i just Svampen 2020. <br>Elfving har i sommar och höst firat stora framgångar med treårige <strong>Phantom Express</strong> (e. Readly Express), som sprungit in över tre miljoner kronor efter andraplatsen i långa E3 och förra lördagens bronsplats i Svenskt Travkriterium.<br>På tvååringssidan har han hingsten <strong>Superstitious</strong> (e. From Above), som var tvåa i ASVT:s Auktionslopp på Solvalla förra veckan.</p>



<p class="wp-block-paragraph">För två år sedan segrade Daniel Wäjersten med egentränade <strong>Feel No Pain</strong> (e. Walner). På lördag startar han <strong>Unusual Tile</strong> (e. Face Time Bourbon), som får Örjan Kihlström i sulkyn. Wäjersten kör själv tyskan <strong>Riet Hazelaar</strong> i Breeders Crown-final i Berlin.</p>



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



<p class="has-drop-cap wp-block-paragraph">En avelshingst dominerar stort när 15 vinnare har korats i Svampen. Veteranen S.J.’s Caviar kan stoltsera med tre vinnare! Det handlar om sönerna <strong>Executive Caviar </strong>och <strong>Global Adventure</strong>, samt stoet <strong>Matchmadeinheaven</strong>, som segrade förra året.</p>



<p class="wp-block-paragraph">Ingen avkomma till S.J.’s Caviar kommer ut i årets upplaga, där de tolv hästarna är fördelade på tio olika fadershingstar.</p>



<p class="wp-block-paragraph">Maharajah och Readly Express har två vardera i jakten på första segern som far i storloppet. Walner är ensam bland fäderna att tidigare ha lämnat en Svampenvinnaren – <strong>Feel No Pain</strong> vann för två år sedan.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/05/lyck2-617x347.jpg" alt="" class="wp-image-90126"/><figcaption class="wp-element-caption">Viktor Lyck. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">En lillasyster till en sexfaldig miljonär dyker upp i Svampen. Det handlar om Viktor Lyck-tränade <strong>De Är Hon</strong> (e. Readly Express), vars mamma Ulrica M. tidigare har lämnat Ulf Stenströmers stjärna <strong>Handsome Brad</strong> (e. Brad de Veluwe). <br>Handsome Brad tränades karriären igenom av Ulf Stenströmer på Axevalla och tog en rad storsegrar. I såväl 2019 års upplaga av Copenhagen Cup som 2020 års Jämtlands Stora Pris var Handsome Brad först i mål och därtill kunde han räkna hem 2019 års upplaga av Olympiatravet i efterhand då målettan Propulsion fråntogs seger i efter hand. Handsome Brad vann 19 av 67 starter, tog rekordet 1.10,5 och tjänade 6.931.546 kronor.</p>



<p class="wp-block-paragraph">Mamma till tre miljonärer är USA-födda <strong>Gossip Gal</strong> (e. S.J.’s Caviar), som i Svampen kan ta kliv mot ytterligare en miljonärska om <strong>Sassy But Classy</strong> (e. Maharajah) når högt i prislistan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/handsomebrad-617x333.jpg" alt="" class="wp-image-226419"/><figcaption class="wp-element-caption">Handsome Brad tillsammans med UIf Stenströmer som tränade hästen karriären igenom. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<h2 class="wp-block-heading">Bästa syskonen till Svampenhästarna</h2>



<ol class="wp-block-list">
<li><strong>Superstitious</strong> – modern <strong>Merge</strong> (e. Viking Kronos) har lämnat Edfromed (e. Farifant), 1.13,4am*/525.096 kr.</li>



<li><strong>Sassy But Classy</strong> – modern <strong>Gossip Gal</strong> (e. S.J.’s Caviar) är mor till Empire (e. Västerbo Prestige), 1.10,7ak*/2.447.393 dkr, Aron the Baron (e. Västerbo Prestige), 1.11,0ak/2.108.474 dkr, och Hill’s Angel (e. Muscle Hill), 1.12,9am/1.282.029 kr.</li>



<li><strong>De Är Hon</strong> – modern <strong>Ulrica M.</strong> (e. Red Xing) har lämnat Handsome Brad (e. Brad de Veluwe), 1.10,5ak/6.931.546 kr, och The Swede (e. Enjoy Lavec), 1.13,1ak/1.023.060 kr.</li>



<li><strong>Unusual Tile</strong> – modern <strong>In Your Dreams</strong> (e. Donato Hanover) första avkomma. Själv sprang In Your Dreams in 1,2 miljoner kr.</li>



<li><strong>Global Got It All</strong> – modern <strong>Differenceadaymade</strong> (e. Muscle Hill) sprng in nästan en miljon och är mor till Global Beware )e. Ready Cash), 1.12,7am*/€147.831.</li>



<li><strong>Pure Athena</strong> – modern <strong>Queen Cash</strong> (e. Ready Cash) har lämnat Trumpie (e. Brad de Veluwe), 1.11,3ak/€83.968, <strong>Super Sarah</strong> (e. Brad de Veluwe), 1.13,7m/628.500 kr, och Pure Atlas (e. Father Patrick), 1.11,7am/628.256 kr.</li>



<li><strong>Hold On Tight</strong> – modern <strong>Frida Zonett</strong> (e. Manofmanymissions) har en avkomma tidigare, treårige Jazz Dancer (e. Propulsion), 1.17,6m/12.400 kr. </li>



<li><strong>Ultra Tile</strong> – norskfödda modern <strong>Noblesse Tile</strong> (e. Donato Hanover) har en tidigare avkomma, treåråige Thankworthy Tile (e. Googoo Gaagaaa), 1.13,9am/167.000 kr.</li>



<li><strong>Vamos</strong> – modern <strong>Heylow</strong> (e. Love You) har en avkomma tidigare, ostartade treåringen Hey You (e. Maharajah).</li>



<li><strong>Nightlife In</strong> – modern <strong>Caddie Lavec</strong> (e. Maharajah) har fem avkommor i startbar ålder och alla har vunnit lopp. Bäst är Kaxig In (e. Ready Cash), 1.13,2am*/889.868 kr, Let Me In (e. Bild Eagle), 1.12,7ak/469.000 kr, och årets Kriterie- och E3-finalist Magic In (e. Face Time Bourbon), 1.12,8am*/449.000 kr.</li>



<li><strong>Phoebe Boko</strong> – modern <strong>Jeppas Olivia</strong> (e. Adrian Chip) har även lämnat Juve Avanti (e. Uncle Lasse), 1.14,9ak/162.000 kr.</li>



<li><strong>Catchagaga Volo</strong> – modern <strong>Catch A Volo</strong> (e. Trixton) har sin första avkomma i Catchagaga Volo.</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/12/hildazonettmal-617x347.jpg" alt="" class="wp-image-246529"/><figcaption class="wp-element-caption">Hilda Zonett och Robert Bergh vid segern mot hingstarna i Svenskt Travkriterium 2000. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Fantastiska 15.434.377 kronor och 49 segrar blev det under en fantastisk karriär med vinster i både Svenskt Travkriterium och Svenskt Travderby för <strong>Hilda Zonett</strong> (e. Spotlite Lobell) i Robert Berghs regi.</p>



<p class="wp-block-paragraph">Hilda Zonett är det senaste stoet i raden att vinna de båda löpningarna, 2000 respektive 2001. Hon blev också en världsstjärna som äldre och vann Prix de France i Paris. Tre gånger deltog hon i Prix d&#8217;Amérique och bäst ifrån sig gjorde hon 2005 med en fjärdeplats.</p>



<p class="wp-block-paragraph">Hilda Zonett verkade i aveln på Västerbo Stuteri och lämnade jordelivet i början av 2022, men hennes blod lever vidare.<br>I Svampen startar hennes dotterdotter <strong>Hold On Tight</strong> (e. Tactical Landing), som i Oskar Kylin Bloms regi vunnit en av fyra starter hittills.</p>



<p class="wp-block-paragraph">Urstarka Hilda Zonett var själv en tidig häst även om det inte blev någon start som tvååring. Hon debuterade i mitten av februari som treåring och innan mars månad av slut hade hon hunnit ta fem segrar!</p>



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



<p class="has-drop-cap wp-block-paragraph">Hela 80.0000 euro var budet för stoet <strong>Sassy But Classy</strong> (e. Maharajah) på den danska nätauktionen Selected Sales i februari förra året. Köpare var Tomas Malmqvist, men hästen finns fortfarande kvar i uppfödaren Panamera Racing/Jens Glud Hansens ägo.</p>



<p class="wp-block-paragraph">Tre av Svampenhästarna såldes på svenska auktioner och mest betalades för <strong>Ultra Tile</strong> (e. Face Time Bourbon), som nederländska Stable Why Not betalade 120.000 kronor för.<br><strong>De Är Hon</strong> (e. Readly Express) ropades tillbaka för 150.000 kronor på Sovlalla Yearling Sale och ägs fortsatt av sin uppfödare Lemitek AB, Aneby. <strong>Catchagaga Volo</strong> (e. Googoo Gaagaa) var struken på norska Klasselöpsauktionen.</p>



<p class="wp-block-paragraph"><strong>Auktionspriser för Svampenhästarna</strong><br><em>Häst (far) – Auktion – Pris</em></p>



<ul class="wp-block-list">
<li>Sassy But Classy – Selected Sales – 80.000 euro</li>



<li>Ultra Tile – Solvalla Yearling Sale – 120.000 kr</li>



<li>Vamos – Next Generation Sale – 90.000 kr</li>



<li>Superstitious* – Next Generation Sale – 25.000 kr</li>
</ul>



<p class="wp-block-paragraph"><em>* Superstitious såldes under namnet Edin.</em></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/03/tunikamal2-617x333.jpg" alt="" class="wp-image-280919"/><figcaption class="wp-element-caption">Tunika vid segern i Örebros tvååringslopp Svampen 2014. Tomas Malmqvist tränade och Björn Goop körde. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">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, liksom Erik Adielsson och Rikard N Skoglund.<br>Goop hoppar upp bakom fältets rikaste häst i Paul Hagoort-tränade stoet <strong>Phoebe Boko</strong> (e. Readly Express), som var trea i årets första storloppsfinal på svensk mark, Breeders Course på Jägersro i början av oktober.</p>



<p class="wp-block-paragraph">Hagoort har dubbla chanser, då <strong>Ultra Tile </strong>(e. Maharajah) startar från spår åtta.</p>



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



<p class="has-drop-cap wp-block-paragraph">Hittills i år har 113 tvååringar i svensk träning tävlat i Sverige och den som tjänat mest är Erwin Bots svenskfödde hingst <strong>Pele Boko</strong> (e. Readly Express), som gjorde ett gästspel på Bots filial på Jägersro i höstas genom att vinna försök och final i Breeders Course för tvååringar.</p>



<p class="wp-block-paragraph">Sju tvååringar med Sverige som bas har sprungit in över 100.000 kronor hittills i karriären och totalt har 24 svenskfödda vunnit lopp. </p>



<p class="wp-block-paragraph"><strong>Vinstrikaste svensktränade tvååringar 2024</strong><br><em>Häst (far) – Tränare – Prispengar</em></p>



<ul class="wp-block-list">
<li><strong>Pele Boko</strong> (e. Readly Express) – Erwin Bot, Jägersro – 600.000 kr</li>



<li><strong>Ghirardelli</strong> (e. Googoo Gaagaa) – Per Nordström, Jägersro – 329.000 kr</li>



<li><strong>Atticus Wibb</strong> (e. Donato Hanover) – Christian Fiore, Halmstad – 312.604 kr</li>



<li><strong>You Bow To No One</strong> (e. Nuncio) &#8211; Claes Sjöström, Solvalla – 220.000 kr</li>



<li><strong>Pure Athena</strong> (e. Bar Hopping) – Fredrik Wallin, Gävle – 186.750 kr</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">34 starter har de tolv tvååringarna hunnit med hittills i karriären, knappt tre starter per häst alltså. De har två till fyra starter i kroppen inför storloppet.<br>Trion <strong>Pure Athena</strong> (e. Bar Hopping), <strong>Hold On Tight</strong> (e. Tactical Landing) och <strong>Vamos</strong> (e. Power) har startat flitigast med fyra framträdanden.</p>



<p class="wp-block-paragraph">När det gäller att passera mållinjen först har sju av tvååringarna vunnit lopp. <strong>Global Got It All</strong> (e. Walner) och <strong>Nightlife In</strong> (e. Day Or Night In) är dessutom obesegrade efter två starter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/matchmadeinheaven1svampengk-617x333.jpg" alt="" class="wp-image-513814"/><figcaption class="wp-element-caption">Matchmadeinheaven vann Svampen och hon är en dotter till S.J.&#8217;s Caviar. Foto Gunilla König/Stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Tidigare vinnare av Svampen</h2>



<p class="wp-block-paragraph"><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>



<li>2023 <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar) – Rikard N Skoglund (Fredrik Wallin) – 1.15,8a</li>
</ul>



<p class="wp-block-paragraph"><em>De två första åren kördes Svampen i två avdelningar, en för ston och en för hingstar/valacker.</em></p>
