
<p class="has-drop-cap wp-block-paragraph">1 Tomas Malmqvist har fyra titlar, Fredrik Wallin och Per Nordström har gjort det två gånger. Vunnit tvååringsloppet Svampen i Örebro alltså. I eftermiddag har både Nordström och Wallin chans att ta ytterligare en seger i grupp II-loppet i Örebro, där elva hästar slåss om 482.938 kronor.</p>



<p class="wp-block-paragraph">Efter strykningen av <strong>Ranomi di Quattro </strong>(e. Readly Express)  återstår elva hästar som gjort 35 starter tillsammans – eller 3,2 starter per häst. Nu ska de tävla om en av karriärens största prischeckar,</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>2024 <strong>Sassy But Classy</strong> (e. Maharajah) – Erik Adielsson (Tomas Malmqvist – 1.13,8a</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="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 Igår tackade V75 för sig i Norge med en omsättning på 87.708.730 kronor och på lördag startar V85 på Jägersro. Mer än 148,5 miljarder har det omsatts sedan starten 1993 och medianomsättningen landade på 76.830.323 kronor.</p>



<p class="wp-block-paragraph">V75 har varit <a href="https://sulkysport.se/kronika/v85-en-avgorande-motor/" data-type="link" data-id="https://sulkysport.se/kronika/v85-en-avgorande-motor/" target="_blank" rel="noreferrer noopener">motorn</a> i svensk travsport och förra året stod V75 för 37,4 procent av bruttoomsättningen på hästspel i Sverige.</p>



<p class="wp-block-paragraph">Igår blev det återigen jackpot när utdelningen uteblev på fem rätt. ATG har bunkrat pengar under lång tid och just nu finns 117.041.054 kronor i ATG:s fond och frågan är hur mycket som betalas ut kommande lördag.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 2020 bröt Mats E Djuse den tolv år långa championsviten signerad Ulf Ohlsson när han tog sitt första kuskchampionat på banan. Idag inkasserar Mats sin sjätte raka titel när <strong>Hagmyren</strong>  (start 12.10) slår igen för säsongen.<br>Mats har ointaglig ledning när han dessutom kör samtliga nio lopp i årsfinalen.</p>



<p class="wp-block-paragraph">Titeln på Hagmyren är faktiskt Mats E Djuses första säkrade 2025. Förra året blev han banchampion på åtta banor: Bergsåker, Bollnäs, Gävle, Hagmyren, Romme, Rättvik, Umåker och Östersund.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/251019.pdfhttps://sulkysport.se/wp-content/uploads/2025/10/251019.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Under de senaste 31 åren har Jim Campbell varit den självklara tränaren för Jules Siegel (Fashion Farms), men nu är det slut. På Harrisburg-auktion bjuds ett dussin ettåringar ut, 22 avelsston och hingstandelar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/08/coolpapabelltmpr220806adamstromstalltz-617x387.jpg" alt="" class="wp-image-337382"/><figcaption class="wp-element-caption">Många ville hylla Hambletonian-vinnaren och till vänster om Cool Papa Bell står tränaren Jim Campbell. Nu tappar han sin största hästägare. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">– Så vitt jag vet är det en fullständig upplösning av alla Fashion Farms hästar. Det skapar ett stort hål för mig och det är ett stort tomrum och jag ska fylla, säger Jim Campbell.</p>



<p class="wp-block-paragraph">Jim Campbell har firat stora framgångar tillsammans med Fashion Farms med hästar som Hambletonian-vinnaren <strong>Tagliabue</strong>, men också med <strong>Broadway Donna</strong>, <strong>Broadway Schooner</strong> och Hambletonian Oaks-vinnaren <strong>Fashion Schooner</strong>. Jules Siegel närmar sig 100 år och är idag 98 år.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Frankrike hittar ”nya” länder att exportera sina produkter till. Nu berättar ”24 au Trot” att sex ston hittat vägen till Portugal; <strong>Iasala de Coquerie</strong> (e. Vaillant Cash), <strong>Janet de Mémartin</strong> (e. Kalusphénio), <strong>Laura du Boult</strong> (e. Valko Jenilat), <strong>La Pernelle</strong> (e. Village Mystic) och <strong>Léa d&#8217;Amour</strong> (e. Bilibili).</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Tyskt Breeders Crown (€38.640) för fem- och sjuåringar hölls igår i Berlin och <strong>Zoom Diamant</strong> (e. Maharajah-Keystone Tabby) tog hem hingstarnas och valackernas uppgörelse. Robin Bakker satt i sulkyn bakom den Paul Hagoort-tränade femåringen som vann på 1.12,4a/1.900 meter före Uccellne (e. Corleone) och Yin Yang (e. Bold Eagle), vilka båda noterade 1.12,5.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/10/robinbakker.jpg" alt="" class="wp-image-514311"/><figcaption class="wp-element-caption">Robin Bakker var en vinnare i Berlin igår.  Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Förra året tog Zoom Diamant hem Breeders Crown för fyraåringar och på meritlistan finns också segrar i Kriterium der Dreijährigen, Adbell-Toddington-Rennen, Buddenbrock-Rennen, Bild-Pokal, Charlie Mills-Rennen och finalen i Super Trot Cup.</p>



<p class="wp-block-paragraph">Modern <strong>Keystone Tabby</strong> (e. Classic Photo), 1.11,5/€53.540, har också lämnat <strong>Timberlake Diamant</strong> (e. Muscle Hill), 1.12,9/€45.330, och <strong>Raspberry Diamant</strong> (e. Muscle Hill), 1.14,2/€22.576.</p>



<p class="wp-block-paragraph">Michael Nimczyk och <strong>Cosmea</strong> (e. S.J.’s Caviar-Cilantro) var överlägsen i Breeders Crown (€44.160) fem- och sjuåriga ston och hon vann på 1,11,4a/1.900 meter. Måltvåan Nortolanda (e. Bird Parker) flyttades ner till tredjeplatsen och Exmes As (e. Crazed) blev istället tvåa på 1.12,1.</p>



<p class="wp-block-paragraph">För Cosmea var det tredje raka triumfen och i starten innan tog hon hem Grosser Preis von Deutschland (€50.000) för fyra- och femåriga ston i Hamburg. <strong>Modern Cilantro</strong> (e. Ganymede), 1.14,4/€56.591, har också lämnat <strong>Calamintha</strong> (e. Timoko), 1.13,5/€47.494.</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/sjunnessonjrgensulky-617x333.jpg" alt="" class="wp-image-59184"/><figcaption class="wp-element-caption">Jörgen Sjunnesson kör flera lopp i Berlin idag. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Och idag fortsätter Breeders Crown-finalerna för de unga travarna i Berlin med både Jörgen Sjunnesson och Stefan Persson på plats. Jörgen Sjunnesson kör fyra hästar och två av dem startar i Breeders Crown (€17.914) för tvååringar.</p>



<p class="wp-block-paragraph">I hingstarna och valackernas uppgörelse sitter han upp bakom Patrick Maleitzkes<strong> Lets Rock S</strong> (e. Love You), 1.18,2ak/€3.650, och i stonas upplaga för de yngsta förmågorna kör han också åt Maleitzke; <strong>Swept Away S</strong> (e. Bar Hopping), 1.16,5ak/€1.800.</p>



<p class="wp-block-paragraph">Jörgen Sjunnesson får också chansen bakom Harry Losses <strong>Valencia</strong> (e. Trixton), 1.13,2ak/€9.750, i Breeders Crown (€31.266) för treåriga ston. Sjunnesson sitter även bakom Losses <strong>Uffizie</strong> (e. Trixton), 1.13,2ak/€50.809, i Breeders Crown (€26.891) för fyraåriga ston.</p>



<p class="wp-block-paragraph">Stefan Persson sätter sig upp bakom Adrian Kolgjinis <strong>Nicolai Hanover</strong> (e. Cash Hanover), 1.14,6am/€10.302, i Breeders Crown (€31.266) för treåriga hingstar och valacker.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/10/berlin19102025.pdf" target="_blank" rel="noreferrer noopener">Här hittar du startlistorna till söndagens tävlingar i Berlin.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Det vimlar av svenska inslag i Champagne-distriktet när Reims arrangerar söndagstävlingar idag. Och passande nog så är svenskarna i farten i Grand Prix du Champagne Gardet (€27.000) över 2.500 meter.</p>



<p class="wp-block-paragraph">Loppet startas med bil och det kan bli svårt för de blågula att rubba Leo Abrivards <strong>Cosmico Polare</strong> (e. Royal Blessed) som kommer med två raka segrar, den senaste tagen just i Reims på 1.12,5a/2.500 meter.</p>



<p class="wp-block-paragraph">De svensktränade hästarna i loppet är: <strong>Steady Victory </strong>(Conrad Lugauer), <strong>Kaxig In </strong>(David Persson), <strong>Vinci Nice</strong> (Johan Untersteiner), <strong>Make It A Star</strong> (Fredrik Wallin), <strong>Ferox Brick</strong> (Jasmine Ising), <strong>Darlington Fame</strong> (Per-Emil Henriksson) och<strong> Master of Zon</strong> (Joakim Eskilsson).</p>



<p class="wp-block-paragraph"><strong>Startlista:</strong></p>



<p class="wp-block-paragraph">2.500 meter autostart.</p>



<p class="wp-block-paragraph"><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Sidney Celeber</strong> (e. Readly Express – Eric Raffin</li>



<li><strong>Look of Love </strong>(e. Ready Cash) – Jules Van Den Putte Jr</li>



<li><strong>Goldwyn Santigny</strong> (e. Tornado Bello) – Jean Charles Piton</li>



<li><strong>Steady Victory</strong> (e. S.J.’s Caviar) – Conrad Lugauer</li>



<li><strong>Kaxig In</strong> (e. Ready Cash) – Benjamin Rochard</li>



<li><strong>Cosmico Polare</strong> (e. Royal Blessed) – Leo Abrivard</li>



<li><strong>Vinci Nice</strong> (e. Maharajah) – Jean Francois Senet</li>



<li><strong>Make It B A Star </strong>(e. Make It Happen) – Damien Bonne</li>



<li><strong>Demidof Cla</strong> (e. Mack Grace Sm) – Matthieu Verva</li>



<li><strong>Ferox Brick </strong>(e. Orlando Vici) – Franck Ouvrie</li>



<li><strong>Darlington Fame</strong> (e. Canepa Hanover) – Pierre Vercruysse</li>



<li><strong>Rustico</strong> (e. Classic Photo) – Thibault Dormigny</li>



<li><strong>Enjoy Banker </strong>(e. Lavec Kronos) – Jo Corbanie</li>



<li><strong>Master of Zon</strong> (e. The Bank) – Christophe Martens</li>
</ol>
