
<p class="has-drop-cap">1Midsommarhelgen 1965 kördes det första travloppet på Mantorptravet. Ikväll (första start 18.20) firar banan sitt 60-årsjubileum och passar på att hedra några stora namn ur historien.</p>



<p>Som familjen Takter. Det var på Mantorptravet karriären tog fart. Bo William Takter blev proffs 1975 och hade några segerrika år innan han flyttade söderut till Jägersro i slutet av 1970-talet. Ikväll hyllas familjen Takter med snabbloppet Takter-trofén, som dock bara bjuder 50.000 kronor i förstapris.<br>Sönerna Jimmy och Johnny Takter har under många år tillhört världseliten, men numera är det Bo W:s barnbarn och Jimmys dotter Nancy som håller familjens fana högst. Nancy är kvinnan bakom de två senaste årens Hambletonianvinnare Tactical Approach och Karl!</p>



<p>Årets Takter-trofé är stängd vid 2,5 miljoner kronor och bland deltagarna finns <strong>Just Perfect Sisu</strong> (e. Brillantissime), som vann norska Sprintermästaren Jarlsberg Grand Prix och slutade tvåa i norska Derbyt för två år sedan i Preben Söviks regi. Ikväll gör hästen – som har två tunga säsonger bakom sig – debut för sin nye tränare Marcus Lindgren.</p>



<p>Mantorptravet hedrar också förre proffstränaren Jörgen Axén med ett minneslopp. Jörgen gick bort i början av 2021 och hans två mest namnkunniga travare under hans proffskarriär var <strong>Jasmin Brick</strong> (e. Super Arnie-Nutria N.), 1.12,5ak/1.431.550 kr, och <strong>Flaque</strong> (e. Speedy Fly-Quadriga), 1.13,2ak*/1.018.100 kr.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2019/06/milliganschoolmidsommarloppet-617x397.jpg" alt="" class="wp-image-46669"/><figcaption class="wp-element-caption">Milligan&#8217;s School och Ulf Eriksson. Foto Simon Hagen/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Förra året gick det undan i rekordfart i Axevallas gulddivisionslopp under Stochampionatshelgen, Axevallalöpning. Tillsammans med Magnus A Djuse segrade svenskfödde <strong>Oracle Tile</strong> (e. Ready Cash) på 1.11,2a/2.640 meter. <br>Segertiden var en sänkning av Milligan’s Schools löpningsrekord med tre tiondelar och dessutom en tangering av <strong>It’s Peppertimes</strong> (e. Muscle Hill) svenska rekord över distansen.</p>



<p>På lördag väntar årets upplaga. 2.640 meter med autostart är förutsättningarna och i potten ligger förutom förstapriset även en biljett till Åby Stora Pris med 1,5 miljoner kronor till vinnaren den 16 augusti.</p>



<p>Tre hästar är hittills inbjudna till Åby Stora Pris: Per Nordströms <strong>Önas Prince</strong> (e. Chocolatoer), samt franska duon <strong>Ibiki de Houelle</strong> (e. Love You) och Harper Hanovers-vinnaren <strong>Inmarosa</strong> (e. Amiral Sacha).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/19v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens V75-tävlingar på Axevalla.</a></p>



<p><strong>Snabbaste vinnarna i Axevallalöpning:</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2024 <strong>Oracle Tile</strong> (e. Ready Cash) – Magnus A Djuse (Kristian Malmin) – 1.11,2a</li>



<li>2022 <strong>Milligan’s School</strong> (e. Yankee Glide) – Mats E Djuse (Stefan Melander) – 1.11,5a</li>



<li>2021 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.11,6a</li>



<li>2017 <strong>Readly Express</strong> (e. Ready Cash) – Jorma Kontio (Timo Nurmos) – 1.11,7a</li>



<li>2016 <strong>Anna Mix</strong> (e. Ludo de Castelle) – Erik Adielsson (Sofia Aronsson) – 1.12,0a</li>



<li>2019 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.12,2a</li>



<li>2018 <strong>Platon Face</strong> (e. Raja Mirchi) – Adrian Kolgjini (Lutfi Kolgjini) – 1.12,4a</li>



<li>2013 <strong>Beckham</strong> (e. Turbo Sund) – Åke Svanstedt – 1.12,5a</li>
</ul>



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



<p class="has-drop-cap">3Måndagen bjuder på tävlingar på tre banor och Rättvik (första start 18.30) är kvällens saxbana. Där dyker en obesegrad travare upp när Oskar Kylin Blom luftar fyraårige <strong>Inyourface C.G.</strong> (e. Nuncio). Hästen debuterade först i februari i år som fyraåring, men gjorde goda intryck i två raka segrar i vintras. Nu är han tillbaka på banan efter nästan fem månaders uppehåll för att hålla förlustnollan intakt och ta tredje raka vinsten.</p>



<p>En jämngammal häst i Rättvik som vunnit desto fler lopp är Daniel Redéns <strong>Ike Zet</strong> (e. Propulsion) som med tränaren i vagnen är ute efter sjunde vinsten på elva försök från tillägg i ett dubbelklasslopp.</p>



<p>Först ut idag är lunchbanan Halmstad (första start 12.20), därfelningspropositionen med spårtrappor – fem av åtta lopp – är stämngda vid 1.200 startpoäng. Fint stammade <strong>Run Champ Run</strong> (e. Googoo Gaagaa) är en son till treippelmiljonärskan <strong>Run Chica Run</strong> (e. Scarlet Knight) som vann Derbystoet och slutade trea i Svensk Trav-Oaks.<br>Nu gör sonen debut i ny regi, amatörtränaren Lova Levin står för regin. Hästen lämnade Per Nordström för Preben Sövik i början av maj, men när Prebens proffslicens drogs in tog Lova över träningen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/250714.pdf" target="_blank" rel="noreferrer noopener">Häst är startlistorna till måndagens tävlingar.</a></p>



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



<p class="has-drop-cap">4Andra benet i tyska Triple Crown – Buddenbrock-Rennen (€25.000) – avgjordes på Mariendorf-banan i Berlin igår och vann gjorde <strong>Seven Seas S </strong>(e. Chapter Seven-Venetian) och Jaap van Rijn på 1.12,3a/1.900 meter. <br>Seven Seas S tilldelades segern sedan målettan och favoritspelade Wellerman diskats för att ha störst John Graham till galopp. Förutom gårdagens Grupp III-vinst tog Seven Seas S hem Auktions-Rennen (€20.000) förra året. </p>



<p>Hela 110.000 euro kostade Seven Seas S på den tyska Derbyauktionen. Han är undan USA-födda <strong>Venetian</strong> (e. Muscles Yankee), vilken är halvbror med kanadensiske topptravaren <strong>Define the World</strong> (e. Duke of York), 1.09,5*/$1.740.839, och <strong>Pretty Edge</strong> (e. Duke of York), 1.11,2/$216.846.</p>



<p>Tyska Breeders Crown-vinnaren <strong>Okura Greenwood</strong> (e. International Moni-Unique Boko) tog hem stonas uppgörelse i Buddenbrock-Rennen (€12.500) för Erwin Bot på 1.13,8a/1.900 meter. </p>



<p>Stoet är undan <strong>Unique Boko</strong> (e. Express Ride), 1.14,3/€27.040, vilken tidigare lämnat <strong>Himoko Greenwood</strong> (e. Timoko), 1.13,7/€25.798. Själv ingår modern i samma syskonskara som <strong>Yendi Boko</strong> (e. From Above), 1.13,5/€58.090.<br>Mormors mor <strong>Janice Jet Boko</strong> (e. Prakas-Speedy Volita), 1.16,1/€18.510, är halvsyster med <strong>Super Darby</strong> (e. Super Bowl), 1.12,1/€214.786.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/7doubledeceiver2-617x333.jpg" alt="" class="wp-image-722994"/><figcaption class="wp-element-caption">Daniel Redén-tränade Double Deceiver och Örjan Kihlström vann försök och final i Sweden Cup. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5I morgon lottas det finska storloppet S:t Michel-Ajo (€142.000) i Mikkeli som avgörs på söndag – och det ser ut att bli en riktig finnkamp. Sex hästar är klara för loppet hittills, tre från Finland och lika många från Sverige.</p>



<p>Förra året segrade Daniel Redén-tränade <strong>Don Fanucci Zet</strong> (e. Hard Livin) på 1.08,7a/1.609 meter. I år mönstrar Redén Sweden Cup-vinnaren <strong>Double Deceiver</strong> (e. Cantab Hall). </p>



<p><strong>Inbjudna till S:t Michel-Ajo (€142.000)</strong><br><em>Häst (far) – Tränare</em></p>



<ul class="wp-block-list">
<li><strong>Callela Nelson</strong> (e. Beer Summit) – Jukka Hakkarainen, Finland</li>



<li><strong>Combat Fighter</strong> (e. From Above) – Antti Ojanperä, Finland</li>



<li><strong>Double Deceiver</strong> (e. Cantab Hall) – Daniel Redén, Sverige</li>



<li><strong>Lightning Stride</strong> (e. Twister Bi) – Katja Melkko, Sverige</li>



<li><strong>Oscar L.A.</strong> (e. Ready Cash) – Alessandro Gocciadoro, Sverige</li>



<li><strong>Ubiquarian Face</strong> (e. Mosaique Face) – Janita Antti-Roiko, Finland</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/fortunadragofont-617x332.jpg" alt="" class="wp-image-742880"/><figcaption class="wp-element-caption">Quite Easy-sonen Fortunadrago Font och Carmine Piscuoglio vann i Montecantini. </figcaption></figure>



<p class="has-drop-cap">6<strong>Fortunadrago Font</strong> (e. Quite Easy-Onice Font) tog hem fyraåringsloppet Gran Premio Nello Bellei (€25.300) i lördags kväll i Montecatini. I sulkyn satt Carmine Piscuoglio och från rygg ledaren kom luckan vid utgången av sista sväng. <br>Enkelt plockade Fortunadrago Font ner ledande Fierobecco Font och höll sedan säkert ifrån sig piggt spurtande <strong>Carpendale</strong> (e. Maharajah) på 1.14,5a/2.060 meter. Tidigare i år har fyraåringen vunnit Gran Premio Firenze (€66.000) igår i Florens.</p>



<p>Modern <strong>Onice Font</strong> (e. Coktail Jet), 1.13,4*/€69.354, ingår i samma syskonskara som Coppa Allevamento Filly-vinnaren <strong>Conversa Sm</strong> (e. Lemon Dra), 1.13,1/€165.114, och Oaks del Trotto-femman <strong>Miss Slid Font Sm</strong> (e. Yankee Slide), 1.13,3/€38.365.<br>Ostartade mormor <strong>Verita’ Lavec</strong> (e. Beseiged-Kramer Samba) är halvsyster med Jimmy Takters storstjärna och avelshingst <strong>Mr Lavec</strong> (e. Speedy Somolli), 1.11,0ak/13.473.915 kr.</p>



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



<p class="has-drop-cap">7Andra försöksomgången i Inter Dominion Trot ($30.000) hölls i lördags på Albion Park och <strong>Bet N Win</strong> (e. What the Hill-Factor the Odds) och Bob Butt vann sin andra raka triumf. Vinnartiden skrevs till 1.13,2a/2.680 meter. <br>Tidigare i år har han också tagit hem Grupp I-loppet Rowe Cup ($196.500) på Auckland Park. Ifjol kom största segern i Grupp I-loppet NZ Metro ($100.000). </p>



<p>Tiondelen snabbare – 1.13,1 – travade sjuårige valacken <strong>Parisian Artiste</strong> (e. Love You-Schleck) vid sin triumf för Tayla French. Det var 14:e segern i karriärens 65 starter. Modern <strong>Schleck</strong> (e. Muscle Mass), 1.13,2/$16.489, startade sex gånger och vann två lopp. </p>



<p>Finalen i Inter Dominion Trot ($500.000) avgörs på lördag på Albion Park. </p>

Fokustema
Sju nyheter vid sju
Läs senare
Firar jubileum med hyllningar
Mantorp firar 60 – och hyllar Takterfamiljen. Snabbast i Axevallalöpningen. Obesegrad på saxbanan. Vilka tar plats i sprinterfesten? Dukar för storloppsfinal ”down under”.
Detta och mer bland måndagens nyheter.
Detta och mer bland måndagens nyheter.
