
<p class="has-drop-cap wp-block-paragraph">1En av Frankrikes största hästägare och uppfödare lägger av med travsporten. Tio år efter triumfens ögonblick i Prix d’Amérique på Vincennes med <strong>Up And Quick</strong> (e. Buvetier d’Aunou), 1.09,4ak/2.383.476, lägger Ecurie Quick Star och Philippe Delon ned satsningen på travsporten.</p>



<p class="wp-block-paragraph">Nu finns datum för avslutet. På Arqana Trotting Mixed Sale den 16 september kommer stallets hästar att säljas ut, däribland 20 ettåringar och 26 tvååringar.<br>Totalt handlar det om ett 70-tal hästar på auktionen.<br>– Alla starthästar som är igång och tävlar (23 hästar, reds. anm.) kommer också att bjudas ut på auktionen. De som har en träningsperiod efter vintermeetinget kommer istället att säljas på Prix d’Amérique-auktionen i januari, säger Philippe Delon till Letrot.</p>



<p class="wp-block-paragraph">Ecurie Quik Star startade på 1990-talet och har firat stora framgångar. Som uppfödare i Frankrike har Ecurie Quick Stars hästar gjort 6.717 starter och vunnit 741 lopp. Siffrorna som ägare är tämligen lika, 766 segrar på 7.027 starter.<br>Bland framgångarna på svensk mark kan nämnas Up And Quicks seger i Hugo Åbergs Memorial 2018. Up And Quick testade även i Elitloppet två gånger och 2018 slutade han femma i finalen.<br><strong>Save The Quick</strong> (e. Jasmin de Flore) tog hem i EM för ston på Solvalla 2013. Hon slutade även tvåa i Trotting Masters-finalenpå Solvalla 2012 och fick stryk i skiljeheat i Åby Stora Pris av <strong>Sebastian K.</strong> (e. Korean) 2013.</p>



<p class="wp-block-paragraph">Avyttringen av fölston har redan inletts, men totalt ska ytterligare 150 höstar byta ägare när Ecurie Quick Star avslutar verksamheten.</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/09/petrisalmela-617x333.jpg" alt="" class="wp-image-352655"/><figcaption class="wp-element-caption">Petri Salmela. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Seger i försök och final av Midsommarloppet i Lindesberg på midsommardagen. Idag när banan är värd för Grand Slam 75 är Petri Salmela-tränade <strong>Who’s The Winner</strong> (e. Who’s Who) tillbaka på samma bana.</p>



<p class="wp-block-paragraph">Uppgiften i Lindesberg idag (första start 13.45) är dock allt annat än tilltalande med tolftespår bakom bilen över sprinterdistans…<br>– Det är sprinterdistans och att ha bakspår den här årstiden är ingen enkel uppgift men jag tror han rundar väldigt många i alla fall. Han har tränat helt normalt och jag tror inte att han har tappat nånting av formen och det kan behövas en sån här gång, säger Petri Salmela till Kanal75.</p>



<p class="wp-block-paragraph">I ett treåringslopp av god klass är E3-finalisten<strong> Olle Fri</strong> (e. Classic Photo) tillbaka på banan och ställs bland annat mot <strong>Herkules A&#8217;lir</strong> (e. Hard Livin), som varit trea i Breeders Crown-försök.</p>



<p class="wp-block-paragraph">Solänget (första start 14.00) kompletterar söndagens utbud på svensk mark och de mest meriterade hästarna tävlaröver 1.140 meter med autostart – i monté.Bland dessa finns elvaårige <strong>Weekend Fun</strong> (e. Jaded) med nästan tre miljoner kronor på kontot.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/07/250727.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">3I måndags var två hästar tränade av Björn Goop först i mål på fransk mark, men bara <strong>Javlar</strong> (e. Charly du Noyer) fick fira vinsten sedan <strong>In Love d’Ecajeul</strong> (e. Love You) flyttats ned till tredjeplatsen sedan han brutit ut på upploppet<br>Söndagen bjuder på trav på 17 franska banor och Goop har laddat om med femårige <strong>Keizo Josselyn</strong> (e. Brillantissime), som vunnit två lopp i Frankrike. Nu väntar start i Prix Association des Courses de Nord över 2.700 meter på gräsbanan. i Vittel. Joan Melis Macias sitter i vagnen.</p>



<p class="wp-block-paragraph">Huvudrollen idag spelar annars Parisbanan Enghien och svenskan Marie Norberg sitter själv upp bakom egentränade <strong>Lady d’Elfe</strong> (e. Bon Copain) i Prix de Clichy (€35.000). Dessutom startar Marie lillasystern <strong>Miss d’Elfe</strong> (e. Discours Joyeux) i Vittel.</p>



<p class="wp-block-paragraph">Sverigebekantingen Ron Kuiper startar fem hästar på två olika banor under söndagen. Fyra av dem kommer ut i Vittel, däribland Alf Nordemot-ägde <strong>Kodiak du Nord</strong> (e. Un Mec d’Heripre), som jagar livets andra seger i 17:e starten.</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/2025/07/arcticfionatototv-617x333.jpg" alt="" class="wp-image-748141"/><figcaption class="wp-element-caption">Arctic Fiona är på väg att kliva förbi stallkamraten Fuego Combo och vinna finska Stokriteriet i Tammerfors. Skärmbild TotoTV</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Finlands främste tränare Pekka Korpi var avstängd i helgen, men det hindrade honom inte från att räkna in två stora unghästsegrar som tränare.</p>



<p class="wp-block-paragraph">Den tyngsta togs i Stokriteriet, Tammakriterium (€43.000), i Tammerfors igår, där Janne Korpi-styrda <strong>Arctic Fiona</strong> (e. Maharajah) plockade ned Pekkas andra häst, storfavoriten <strong>Fuego Combo</strong> (e. Express Duo), sista biten. Arctic Fiona tog ledningen, släppte till Fuego Combo och tog sig förbi i en rykande snabb avslutning, där täthästen travade 1.07,0.<br>Segertiden skrevs till 1.14,6a/2.100 meter och belönades med 20.000 euro. Arctic Fiona var tvåa bakom Fuego Combo i tvååringsfinalen Hevosenomistajapokaali (€39.600) och fick sin revansch nu. </p>



<p class="wp-block-paragraph">Arctic Fiona är en dotter till svenskfödda <strong>Cyris Lane</strong> (e. Muscle Hill), 1.17,8m/8.332 kr, som lämnat Arctic Dominant (e. Andover Hall), 1.12,2ak/558.150 kr. Själv är hon syster till Derbyvinnaren <strong>Cyber Lane</strong> (e. Raja Mirchi), 1.09,7ak/14.340.395 kr.</p>



<p class="wp-block-paragraph">I fredags i Vieremä tog Pekka Korpis stora Derbyhopp <strong>Arctic Emerald</strong> (e. Express Duo) hem fyraåringsloppet Einari Vidgren Memorial (€31.500) tillsammans med Janne Korpi. Även detta före en stallkamrat, Arctic Estelle (e. Express Duo), på 1.15,1a/2.140 meter. <br>Arctic Emerald har många stora segrar bland sina 21 vinster på 37 starter, men fick nöja sig med andraplatsen i finska Kriteriet förra året bakom <strong>Lil Runner</strong> (e. So Perfect), som tränas av Matti Nisonen och slutade åtta i fredagens storlopp.</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/2025/05/9ecorsagplotteriafinale1-617x378.jpg" alt="" class="wp-image-714922"/><figcaption class="wp-element-caption">Magnus A Djuse och Always Ek vinner Gran Premio della Lotteria och plockar ner Executiv Ek sista biten. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Grupp I-löpningen Gran Premio Due Mari (€121.000) avgörs i Taranto ikväll över sprinterdistans med flera italienska topptravare och i loppet finns också svenskfödde Usain Töll (e. Googoo Gaagaa) med. </p>



<p class="wp-block-paragraph">Alessandro Gocciadoro har två hästar till start och väljer själv att köra Lotteria-vinnaren Always Ek (e. Filipp Roc), medan han lånar ut  Dany Capar (e. Exploit Caf) till Gabriele Gelormini och som vunnit dubbla Grupp I-lopp i år; Gran Premio Costa Azzurra (€220.000) och Gran Premio Duomo (€154.000).</p>



<p class="wp-block-paragraph"><strong>Gran Premio Due Mari (€121.000)</strong><br>Äldre travare, 1.600 meter autostart<br><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>Deus Zack</strong> (e. Victor Gio) – Edoardo Loccisano</li>



<li><strong>Always Ek </strong>(e. Filipp Roc) – Alessandro Gocciadoro</li>



<li><strong>Usain Töll</strong> (e. Googoo Gaagaa) – Gennaro Amitrano</li>



<li><strong>Bleff Dipa </strong>(e. Mister J.P.) – Roberto Vecchione</li>



<li><strong>Dany Capar</strong> (e. Exploit Caf) – Gabriele Gelormini</li>



<li><strong>Zefiro d’Ete</strong> (e. Mago d’Amore) – Gaetano di Nardo</li>



<li><strong>Evandro Degli Dei</strong> (e. Trixton) – Vincenzo Gallo</li>



<li><strong>Calima di Poggio</strong> (e. Crazed) – Mario Minopoli Jr.</li>



<li><strong>Encierro</strong> (e. Tobin Kronos) – Gaspare Lo Verde</li>



<li><strong>Callisto</strong> (e. Nad al Sheba) – Giuseppe De Filippis</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6Amatörtränaren Lars-Gunnar Gustavsson från Arvika och med licens i Årjäng gjorde inte resan till Norges V75-bana Momarken förgäves igår. Han sexåriga kallblod <strong>Troll Winther</strong> (e. Ingbest) slog nämligen till i en spårtrappa tillsammans med Eirik Höitomt och spurtade hem 40.000 norska kronor på 1.30,3a/2.140 meter.</p>



<p class="wp-block-paragraph">Den norskfödde hästen köptes av Lars-Gunnar Gustavsson förra våren och gårdagens seger var den andra i karriären på 25 starter. Troll Winther köptes mer eller mindre som ridhäst förra året, men har hittat tillbaka till formen på tävlingsbanan.</p>



<p class="wp-block-paragraph">Den störste vinnaren på Momarken var annars tioårige <strong>Sam The Man</strong> (e. Wishing Stone), som satte nytt bakrekord när han vann Per Rakkestads Minneslopp och 80.000 kronor på 1.10,4a/1.640 meter tillsammans med Erlend Rennesvik.<br>Frode Hamres italienske segermaskin <strong>Extreme Point</strong> (e. Espoir Prestance) med 20 segrar på 34 starter före gårdagens lopp bjöd hårt motstånd som tvåa och kom hem på samma tid som vinnaren.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Idag avgörs den 51:a upplagan av Traber S:t Leger (€10.000) i Baden i Österrike och storfavorit till segern är Derbyvinnaren <strong>Face Time Spada</strong> (e. Face Time Bourbon) som vunnit båda sina starter i år.<br>Bland motståndarna finns <strong>Profitable Invest</strong> och <strong>Super Crown</strong>, som slutade tvåa respektive trea bakom Face Time Spada i Österrikiskt Derby. </p>



<p class="wp-block-paragraph"><strong>Traber S:t Leger (€10.000)</strong><br>Fyraåringar, 2.100 meter, autostart<br><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li><strong>Super Crown</strong> (e. Dijon) – Kurt Sokol</li>



<li><strong>Face Time Spada</strong> (e. Face Time Bourbon) – Gerhard Mayr</li>



<li><strong>Sixpak</strong> (e. Muscles Yankee) – Franz Konlechner</li>



<li><strong>Kaiser RZ</strong> (e. Light Kronos) – Mario Zanderigo</li>



<li><strong>Big M Eck</strong> (e. Odessa Santana) – Christoph Schwarz</li>



<li><strong>Profitable Invest</strong> (e. Cristal Money) – Josef Spaber</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Prix d’Amérique-vinnare lägger av
Storhästägare säljer ut alla hästar. Lindesbergsexpert från omöjligt läge? Avstängd Korpi vann dubbla storlopp. Lotteriavinnaren tillbaka på banan. Arvikaamatör tog V75-seger i Norge.
Detta och mer bland söndagens nyheter.
Detta och mer bland söndagens nyheter.
