
<p class="has-drop-cap wp-block-paragraph">1Tomas Malmqvist har tre titlar, Fredrik Wallin och Per Nordström har gjort det två gånger, Joakim Elfving och Daniel Wäjersten en gång vardera. Vunnit tvååringsloppet Svampen i Örebro alltså.</p>



<p class="wp-block-paragraph">I eftermiddag har kvintetten chansen att fylla på meritlistan med ytterligare en seger i grupp II-loppet i Örebro, där tolv hästar slåss om tidernas näst högsta prischeck, 595.000 kronor. Bara 2022 års vinnare <strong>Feel No Pain </strong>(e. Walner) har tjänat mer, 600.000 kronor.</p>



<p class="wp-block-paragraph">Per Nordström har vunnit loppet med <strong>Denim Boko</strong> (e. Chocolatier) 2012 och <strong>Dixi Sisu</strong> (e. Ready Cash) 2015 och rustar med obesegrade <strong>Nighlife In</strong> (e. Days Or Night In) i årets upplaga.<br>– Allt har gått som på räls med honom både i uppträningen och i segerloppen. Det är en långstegad herre som tar livet med en klackspark. Han har gått sina normala jobb och allt är normalt, säger Per Nordström.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/infor-svampen-st-vill-gomma-tvaaringarna/" target="_blank" rel="noreferrer noopener">Läs hela intervjun med Jägersrotränaren om Nightlife In och där han kritiserar travförbundets sätt att behandla tvååringssporten.</a></p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Svampen</h2>



<p class="wp-block-paragraph"><em>År/vinnare (far) – Kusk – Tränare – Segertid</em></p>



<ul class="wp-block-list">
<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>2012 <strong>Denim Boko</strong> (s e. Chocolatier) – Per Nordström  – 1.14,0a</li>



<li>2015 <strong>Dixi Sisu</strong> (s e. Ready Cash) – Per Nordström – 1.14,0a</li>



<li>2021 <strong>Tetrick Wania</strong> (h e. Muscle Hill) – Riina Rekilä – 1.14,0a</li>



<li>2020 <strong>Mi Ma Ohrtus</strong> (h e. Jocose) – Rikard N Skoglund (Joakim Elfving) – 1.14,2a</li>



<li>2016 <strong>Executive Caviar</strong> (h e. S.J.’s Caviar) – Björn Goop (Joakim Lövgren)  – 1.14,3a</li>



<li>2022 <strong>Feel No Pain</strong> (s e. Walner) – Daniel Wäjersten – 1.14,5a</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/svampen-tranare-talanger-och-toppsyskon/" target="_blank" rel="noreferrer noopener">Läs om dagens deltagare, Svampens historia och annat smått &#038; gott i ”Det snackas om Svampen” här!</a></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/2024/10/241016v86succe-617x333.jpg" alt="" class="wp-image-648677"/><figcaption class="wp-element-caption">Åtta rätt och 113.638 kronor i ren vinst blev det för Sulkysports spelförslag till V86 i onsdags, signerat Magnus Blom.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Åtta rätt och 113.638 kronor i vinst på V86 i onsdags. Sulkysports tipsexpert Magnus Blom visade lysande spelform, men vilar inte på lagrarna. Nu har han laddat om till Örebros V75-omgång, där han har två starka förslag till enkelstreck. <br><em>”<strong>Missle Hill</strong> i V75-3 har inte vunnit på ett tag, men här ser det ut som spets och slut tillsammans med Örjan Kihlström. <strong>Marseille</strong> i V75-2 är mer av en chansning. Men han går ned i klass och för Kenneth Haugstad gäller det att sätta in attacken i tid,” </em>skriver Magnus Blom.</p>



<p class="wp-block-paragraph">Vad tycker då tränare Daniel Redén om sin åttafaldige miljonär Missle Hill (e. Muscle Hill)?<br>– Han satt fast med mycket sparat i ett bra lopp senast. Han ser riktigt fin ut i jobbet och spår ett på Örebro tycker i alla fall jag är väldigt bra. Formen är riktigt bra också så jag tycker det känns bra på förhand. Han går som han brukar göra, säger Daniel Redén på Stall Zets hemsida.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-missle-hill-leder-hela-vagen-i-guld/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports stora tipsgenomgång inför Örebros omgång.</a></p>



<p class="wp-block-paragraph">Missa inte andelsspelen hos vår samarbetspartner Travnet på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V75_2024-10-19_32_5" target="_blank" rel="noreferrer noopener">Här finns Travnets andelar.</a></p>



<p class="wp-block-paragraph">Ytterligare en svensk bana tävlar idag. I Rättvik (start 18.53) ikväll väntar åtta lopp– och på tal om Svampen. 2020 års vinnare av storloppet, <strong>Mi Ma Ohrtus</strong> (e. Jocose), dyker upp från tillägg i högsta klassen. Uppfödaren och ägarinnan Anna Maria Hanses sköter träningen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/241019.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Jan-Olov Persson har vunnit Stokriteriet i Norge fem gånger, men i Oaks har det hittills ”bara” blivit två vinster genom åren: <strong>Eldsiri</strong> 2009 och <strong>Majblomster</strong> ifjol. I eftermiddag väntar årets upplaga på Momarken och Persson sitter med trumf på hand när han startar <strong>Hertiginnan Stöen</strong> (e. Tekno Odin).<br>Stoet har vunnit Kriteriestoet både på Dannero och Bjerke i år och redan passerat miljonen intjänat i karriären. Mats E Djuse är tillbaka i sulkyn. Vid storsegern på Bjerke i senaste starten kördes Hertiginnan Stöen av lillebror Magnus.<br>Från innerspår ställs Hertiginnan Stöen mot bland andra Öystein Tjomslands svenskfödda <strong>Stavre Maggan</strong> (e. Tekno Odin) och Anders Wallin-tränade <strong>Björgen</strong> (e. Bork Odin). </p>



<p class="wp-block-paragraph">Ytterligare en svenskfödd- och tränad häst har segrat i Oaks. 2011 slog Niclas Torstemo till med egentränade <strong>Pyrodi</strong> (e. Moe Odin).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/6majblomster3-617x333.jpg" alt="" class="wp-image-618978"/><figcaption class="wp-element-caption">Majblomster vid segern i Derbystoet i Östersund i augusti före Voje Lotta. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Fjolårsvinnaren <strong>Majblomster</strong> (e. Tekno Odin) ger sina kullkamrater chansen till revansch i Oaksrevanschen, som är en toppupplaga med kullens tre starkaste ston. Majblomster utmanas av Stoderbyvinnaren på Bjerke, <strong>Voje Lotta</strong> (e. Ängsborken), och <strong>Prinsesse Ness Tjo</strong> (e. Moe Odin).</p>



<p class="wp-block-paragraph">På varmblodssidan saknas däremot svenska tränarsegrar i historien. Den långa svinten kan Bodentränaren Petri Salmela bryta när han sänder vinnaren av norska Stokriteriet till Momarken. <strong>Lilium Sisu</strong> (e. Face Time Bourbon) klev fram som etta bland stona i den norska kullen när hon sänkte löpningsrekordet med sju tiondelar. Mika Forss sitter som vanligen i sulkyn och precis som i kallblodsklassen väntar 300.000 kronor på vinnaren.</p>



<p class="wp-block-paragraph">Årjängstränaren Paw Mahony gör resan till Mysen med sin stjärna <strong>Millmighty</strong> (e. Make It Happen), som ger sig ut i ett riktigt styrkeprov. 4.140 meter är grunddistansen i Lionels Höstmaraton med 125.000 norska kronor till vinnaren och Millmighty startar från 60 meters tillägg. Ytterligare 20 meter bakom jagar en av Europas mest meriterade kuskar – Jos Verbeeck gästar Momarken för att köra <strong>Evening Quick</strong> (e. Magnificient Rodney).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/mo20241019baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Momarkens stordag.</a></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/2024/02/riethazelaar-617x333.jpg" alt="" class="wp-image-547861"/><figcaption class="wp-element-caption">Riet Hazelaar. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Det är Breeders Crown-helg på Berlinbanan Mariendorf och lördagen tillskrivs de fem- till sjuåriga hästarna. Fyra svensktränade hästar reser söderut för att tävla om 39.174 euro i två klasser, där vinnarna tar hem 19.587 euro.</p>



<p class="wp-block-paragraph">En som redan vet hur det känns att vinna tyskt Breeders Crown som äldre är Johan Untersteiners sjuåring <strong>Toto Barosso</strong> (e. Ready Cash), som är titelförsvarare i loppet. Hästen slutade även tvåa i äldrefinalen 2022 och Johan kör själv i dagens storlopp.</p>



<p class="wp-block-paragraph">På stosidan står en svensktränad trio på startlinjen med Daniel Wäjerstens <strong>Riet Hazelaar</strong> (e. S.J.’s Caviar) i favoritposition. Hon ställs bland annat mot Per Henriksen-tränade <strong>Mose Eagle </strong>(e. Bold Eagle) och Adrian Kolgjinis <strong>Donato Princess </strong>(e. Donato Hanover).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/berlin19102024.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens Breeders Crown-finaler i Berlin.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5På tal om Breeders Crown…årets Hambletonianvinnare <strong>Karl</strong> (e. Tactical Landing) är tillbaka på tävlingsbanan när det är treåringarnas tur att kvala i amerikanska Breeders Crown på Meadowlands i natt.</p>



<p class="wp-block-paragraph">Både hingstarna/valackerna och stona gör upp i två försök vardera där de fem främsta går till final och det är svensktätt i startlistorna.<br>Nancy Takters Karl, som inte hade sin bästa dag som fyra i Kentucky Futurity i senaste starten, ställs mot fyra svensktränade treåringar, däribland svenskfödde och svenskägde<strong> Tony Adams</strong> (e. Muscle Hill) med fyra miljoner kronor på kontot.</p>



<h2 class="wp-block-heading">Svensktränade hästar i BC-försöken</h2>



<p class="wp-block-paragraph"><strong>Treåriga hingstar/valacker:</strong></p>



<ul class="wp-block-list">
<li>Marcus Melander: <strong>Security Protected</strong> (e. Father Patrick), <strong>Wild Ticket</strong> (e. Chapter Seven), <strong>Vic Zelenskyy</strong> (e. Greenshoe)</li>



<li>Åke Svanstedt: <strong>Mr Bluebird</strong> (e. Six Pack), <strong>Amazing Catch</strong> (e. Walner), <strong>Tony Adams </strong>(e. Muscle Hill), <strong>Daiquiri Hanover</strong> (e. Bar Hopping)</li>



<li>Nancy Takter: <strong>Karl </strong>(e. Tactical Landing)</li>



<li>Lucas Wallin: <strong>For July </strong>(e. Greenshoe)</li>
</ul>



<p class="wp-block-paragraph"><strong>Treåriga ston:</strong></p>



<ul class="wp-block-list">
<li>Marcus Melander: <strong>Date Night Hanover</strong> (e. Chapter Seven)</li>



<li>Åke Svanstedt: <strong>French Champagne</strong> (e. Muscle Hill), <strong>Warrawee Michelle</strong> (e. Walner), <strong>Senorita Palema </strong>(e. Chapter Seven)</li>



<li>Lucas Wallin: <strong>Soiree Hanover</strong> (e. Walner)</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/10/m10190620p.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till nattens tävlingar på Meadowlands.</a></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/2023/01/danielreden1-617x333.jpg" alt="" class="wp-image-402846"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Fyraåringar mot äldre hästar över lång distans och 36.000 euro till vinnaren. Det är förutsättningarna för lördagens storlopp på finsk mark, S:t Leger i Björneborg.<br>En svensktränad häst slåss om den saftiga prischecken, Daniel Redén-tränade <strong>Imperator</strong> (e. Maharajah), som slutade tvåa i försöket bakom fyraåriga stoet <strong>Callela Ellen</strong> (e. Love You) förra veckan. Det andra försöket vanns av <strong>Massimo Hoist</strong> (e. Muscle Hill). </p>



<p class="wp-block-paragraph">Finska S:t Leger är öppet för alla åldrar, med både fyraåringar och ston får 20 meters gottgörelse. För fyraåriga ston ger det 40 meters försprång på de äldre hästarna och fyra ston födda 2020 tar chansen från startfållan.<br>Mest meriterad i fältet är ett sjuåriga sto. Unghäststjärnan <strong>An-Dorra</strong> (e. Maharajah) med segrar i Kriteriet, Stokriteriet och Stochampionatet samt andraplats i Derbyt på meritlistan gjorde i våras comeback efter ett 21 månader långt tävlingsuppehåll. Som i fornstora dagar är dock inte stoet som vunnit två av 16 starter efter comebacken.</p>



<h2 class="wp-block-heading">Startlista, finskt S:t Leger</h2>



<p class="wp-block-paragraph"><strong>Björneborg lördag, förstapris: 36.000 euro</strong><br><em>2.600 meter:</em></p>



<ol class="wp-block-list">
<li>Callela Ellen (e. Love You) – Esa Holopainen</li>



<li>Icella (e. Maharajah) – Antti Teivainen</li>



<li>Nothing Comes (e. Coktail Jet) – Tommi Kylliäinen</li>



<li>Fortnite (e. Monteil) – Jere Hurme <br><em>2.620 meter:</em></li>



<li>Odin Orden (e. Orlando Vici) – Johan Utala</li>



<li>True Colors (e. Zola Boko) – Jere Kiveinen</li>



<li>An-Dorra (e. Maharajah) – Ville Tonttila</li>



<li>Ava di Alessia (e. Expres Duo) – Ari Moilanen</li>



<li>God Hyperion (e. Brad de Veluwe) – Henri Bollström</li>



<li>Sahara Vision (e. R.C.Royalty) – Jarmo Saarela <br><em>2.640 meter:</em></li>



<li>Skyfall Shine (e. Muscle Hill) – Jukka Torvinen</li>



<li>Main Stage (e. Prodigious) – Santtu Raitala</li>



<li>Massimo Hoist (e. Muscle Hill) – Hannu Torvinen</li>



<li>Imperator (e. Maharajah) – Olli Koivunen</li>



<li>Marschall Match (e. Zola Boko) – Niko Jokela</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">720 starthästar finns i den 41 hästar stora katalogen till kvällens internetauktion hos Travera. Bland dessa finns fyraåringarna <strong>Macao Keeper</strong> (e. Southwind Frank) och <strong>Kalypso Sisu</strong> (e. Readly Express). <br>Macao Keeper har vunnit fem av 15 starter, däribland försök och final i rikstotons klass II i augusti. Kalypso Sisu vann lopp på Solvalla så sent som förra fredagen.</p>



<p class="wp-block-paragraph">Av tolv fölston till försäljning är sju dräktiga och <strong>Tango Brodda</strong> (e. Muscle Hill) säljs tillsammans med sitt årsföl med Calgary Games som far. </p>



<p class="wp-block-paragraph">På unghästsidan finns fyra ettåringar (pappor Campo Bahia, Maharajah, Very Kronos och Ingbest), och lika många tvååringar med Aperfect Yankee, Brillantissime, Hayden Hanover och Maharajah som fäder. Dessutom säljs en betäckningsrätt för 2025 i Greenshoe.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Ny stjärna växer upp i Svampen?
Tränarna som vet hur man vinner Svampen. Laddad för ny tipssuccé! Svenska Stokriterievinnare jagar ny norskt klassiker. Verbeeck mot Mahony på Momarken. Karl tillbaka på banan. Untersteiner mot andra BC-segern. Redén jagar storpott i Finland.
Detta och mer i lördagens ”sju nyheter vid sju”.
Detta och mer i lördagens ”sju nyheter vid sju”.
