
<p class="has-drop-cap">1 I år har sju hästar vunnit på en tid under 1:50 (1.08.4) i världen och det är nytt rekord för snabba vinnartider under en och samma säsong. Det tidigare rekordåret 2019 har skickats till historieböckerna. Då vann fem travare på 1.08,2 eller bättre.</p>


<div class="factbox right minify">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									År – 1.08,2 &#038; snabbare								</h3>
<div class="content">
<ul class="wp-block-list">
<li>2014 – 1</li>
<li>2015 – 1</li>
<li>2016 – 0</li>
<li>2017 – 2</li>
<li>2018 – 5</li>
<li>2019 – 5</li>
<li>2020 – 1</li>
<li>2021 – 4</li>
<li>2022 – 3</li>
<li>2023 – 1</li>
<li>2024 – 7</li>
</ul></div>
</p></div>
</p></div>
</p></div>
<div class="expand">
						<span class="text">Expandera</span><br />
						<span class="icon sprites"></span>
					</div>
</p></div>
</p></div>



<p>Åke Svanstedt och <strong>Sebastian K.</strong> (e. Korean) var först under 1:50 över den engelska milen och travade 1.07,7 på Pocono Downs 2014. Det absoluta världsrekordet har <strong>Homicide Hunter</strong> (e. Mr Cantab) med tiden 1.07,6 från Red Mile 2018.</p>



<p>Följande sju hästar har vunnit 1.08,2 eller en snabbare tid i år:</p>



<p><strong>Namn (far) – Tränare – Tid</strong></p>



<ul class="wp-block-list">
<li><strong>Horsy Dream</strong> (h 7 e. Scipion du Goutier) – Pierre Belloche – 1.08,0</li>



<li><strong>Southwind Tyrion</strong> (h 6 e. Muscle Hill) – Åke Svanstedt – 1.08,0</li>



<li><strong>Jiggy Jog</strong> (s 5 e. Walner) – Åke Svanstedt – 1.08,0</li>



<li><strong>Vernissage Grif </strong>(h 10 e. Varenne) – Alessandro Gocciadoro – 1.08,1</li>



<li><strong>Winner’s Bet </strong>(h 4 e. Walner) – Nancy Takter – 1.08,1</li>



<li><strong>Tactical Mounds</strong> (s 4 e. Tactical Landing) – Megan Scran – 1.08,2</li>



<li><strong>Lexus Kody </strong>(v 6 e. Archangel) – Ron Burke – 1.08,2</li>
</ul>



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



<p class="has-drop-cap">2 På Select European Yearling Sale i Deauville igår såldes 21 svenskregistrerade ettåringar för totalt 1.001.000 euro, vilket gav ett snittpris på 47.667 euro, eller 540.000 kronor i svensk valuta.<br>15 ettåringar ropades åter för totalt 417.000 euro.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/82min-617x411.jpg" alt="" class="wp-image-627255"/><figcaption class="wp-element-caption">Nuance Josselyn. Foto: Arqana Trot.</figcaption></figure>



<p>Allra mest spenderade dansken Bertel Maigaard (Costa Stable) och han ropade in stoet <strong>Nuance Josselyn</strong> (e. Calgary Games-Uza Josselyn) för 160.000 euro.</p>



<p>Modern <strong>Uza Josselyn </strong>(e. Love You-Teza Josselyn), 1.08,7ak/€1.278.078, är det vinstrikaste danskregistrerade stoet genom tiderna och vann 33 lopp på 79 starter och nämnas kan Gran Premio della Nazione, Sto-EM, Årjängs Stora Sprinterlopp, Prix de Chateaudun, Prix du Plateau du Gravelle, Prix de Washington och Grand Prix Anjou Maine.</p>



<p>Uza Josselyn har en tävlande avkomma och <strong>Keen Lady Josselyn</strong> (e. Maharajah), 1.15,9ak*/138.761 dkk, har startat sex gånger (2-3-1) och finns numera i träning hos Steen Juul.</p>



<h2 class="wp-block-heading">Så gick det för de svenskfödda ettåringarna i Deauville: </h2>



<p><strong>Namn (kat.nr) – Kön – Stamtavla – Pris (€) – Köpare</strong></p>



<ul class="wp-block-list">
<li><strong>Nuance Josselyn</strong> (82) – sto – Calgary Games-Uza Josselyn<br>Pris: 160.000 euro, Bertel Maigaard</li>



<li><strong>Itself Kronos </strong>(53) – hingst – Face Time Bourbon-Zourane Kronos <br>Pris 110.000 euro, Darby Stable</li>



<li><strong>Istrian Kronos</strong> (50) – hingst – Bar Hopping-Union Kronos <br>Pris: 80.000 euro, Union Stable</li>



<li><strong>King Size </strong>(55) – hingst – Tactical Landing-Gossip Gal <br>Pris: 80.000 euro, Björn Goop</li>



<li><strong>Rainer Schermer </strong>(85) – hingst – Face Time Bourbon-Lieve Schermer <br>Pris: 80.000 euro, Hugo W. Langeweg</li>



<li><strong>Mister Navajo</strong> (67) – hingst – Muscle Hill-Vanity Matters <br>Pris: 72.000, Cristian Rizzo</li>



<li><strong>Monsoon Rain</strong> (69) – hingst – Readly Express-Alexia Ås <br>Pris: 67.000 euro, Team Ojanperä</li>



<li><strong>Amber Wynn</strong> (7) – sto – Calgary Games-U Take the Cake<br>Pris: 60.000 euro, Stall Courant AB</li>



<li><strong>Shatter Dream</strong> (94) – sto – Father Patrick-Laurel America<br>Pris: 55.000 euro, Christoffer Eriksson</li>



<li><strong>Riva Schermer</strong> (89) – sto – Tactical Landing-Golden Girl<br>Pris: 35.000 euro, Björn Goop</li>



<li><strong>Roald Schermer</strong> (90) – hingst – Tactical Landing-Trecciadoro Rex<br>Pris: 35.000 euro, Björn Goop</li>



<li><strong>McEnroe Laser</strong> (62) – hingst – Readly Express-Olivia Lavec<br>Pris: 30.000 euro, Union Stable</li>



<li><strong>Rex F Schermer</strong> (88) – hingst – Father Patrick-Kenway Fortuna<br>Pris: 26.000 euro, Joost van Riet</li>



<li><strong>Raina Schermer</strong> (84) – hingst – Face Time Bourbon-Katinka Bourbon <br>Pris: 26.000 euro, Jörgen S Eriksson</li>



<li><strong>Aretha Franklin </strong>(9) – sto – Father Patrick-Zenta<br>Pris: 24.000 euro, Gaetano Pezone</li>



<li><strong>Nideck Ultra</strong> (76) – hingst – Hohneck-Borups Ultra<br>Pris: 18.000 euro, Per Nordström</li>



<li><strong>Iloyez </strong>(sto e. Love You-April Wise As)<br>Pris: 16.000 euro, Christoffer Eriksson</li>



<li><strong>Veronica Dream</strong> (5) – sto – Fabulous Wood-The Lisi<br>Pris: 12.000 euro, Per Nordström</li>



<li><strong>Wilson Wynn</strong> (6) – hingst – Greenshoe-Jolie Journey<br>Pris: 7.000 euro, Manuel Casillo</li>



<li><strong>Clog </strong>(12) – hingst – Greenshoe-Star Bright Hill<br>Pris: 6.000 euro, Ecurie de l’Empereur</li>



<li><strong>Britney Wynn</strong> (10) – sto – Vivid Wise As-Isole Face<br>Pris: 2.000 euro, Mats Larsson</li>
</ul>



<h2 class="wp-block-heading">Åter:</h2>



<ul class="wp-block-list">
<li><strong>Daisy Cash </strong>(13) – sto – Ready Cash-Unique Dream – €70.000</li>



<li><strong>Nightdance </strong>(78) – sto – Calgary Games-Flashdance – €60.000</li>



<li><strong>Rose Wynn</strong> (92) – sto – Gimpanzee-Pink Drink – €45.000</li>



<li><strong>Busy Miss Lizzy</strong> (11) – sto – Calgary Games-Hill’s Angel – €40.000</li>



<li><strong>Prince Wynn</strong> (83) – hingst – Chapter Seven-Champagne Cocktail – €40.000</li>



<li><strong>Nightbird</strong> (77) – hingst – Calgary Games-Pennsylvania – €32.000</li>



<li><strong>Anna Wynn</strong> (8) – sto – Muscle Hill-Awesome Annie – €25.000</li>



<li><strong>Dixie Dynamite </strong>(14) – sto – Tactical Landing-Maharani de Baroda – €25.000</li>



<li><strong>La Castiglione</strong> (56) – sto – Father Patrick-Lovely Eyes – €23.000</li>



<li><strong>Rodgers Flevo</strong> (91) – hingst – Bar Hopping-Abracantabra – €22.000</li>



<li><strong>Nausicaa </strong>(75) – sto – Googoo Gaagaa-Jagerita – €14.000</li>



<li><strong>Noelle Supreme</strong> (80) – sto – Donato Hanover-Zahara Goj – €12.000</li>



<li><strong>The Flash </strong>(1) – sto – Fabulous Wood-Dreamforlove – €9.000</li>



<li><strong>Natasia </strong>(74) – sto – Bird Parker-Bagatelle – €8.000 </li>



<li><strong>Miss Noblesse</strong> (66) – sto – Royal Dream-Jentry – €2.000</li>
</ul>



<p><a href="https://sulkysport.se/fem-ettaringar-till-goop/" data-type="link" data-id="https://sulkysport.se/fem-ettaringar-till-goop/" target="_blank" rel="noreferrer noopener">Och här hittar du samtliga svenskköp.</a></p>



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



<p class="has-drop-cap">3 Arqana Trot ligger inte på latsidan och idag drar den stora franska unghästauktionen Ventes de Yearlings Sélectionnés igång. Under tre dagar (28-30 augusti) bjuds det ut 502 franskfödda ettåringar i Deauville.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/skarmavbild20240827kl.21.14.03-617x374.jpg" alt="" class="wp-image-627261"/></figure>



<p>Förra året köpte Philippe Allaire den dyraste ettåringen och hingsten <strong>Mersault</strong> (e. Ready Cash-Crista Maris) och prislappen var 250.000 euro. </p>



<p><a href="https://www.arqana-trot.com/resultats/select-european-yearling-sale/209" data-type="link" data-id="https://www.arqana-trot.com/resultats/select-european-yearling-sale/209" target="_blank" rel="noreferrer noopener">Här kan du beskåda hästarna som säljs i Deauville.</a></p>



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



<p class="has-drop-cap">4 <strong>Åby </strong>(första start 18.27) och <strong>Solvalla</strong> (första start 18.15) delar på värdskapet när det gäller V86-omgången, som dessutom kryddas med en jackpot på 14 miljoner kronor.</p>



<p>På Åby tilldrar det största intresset kring Count´s Pride-pokalen som dessutom är V86-5. Förstapriset är 100.000 kronor och Solvallatränaren Claes Sjöström skickar dit <strong>Ronno</strong> (e. Walner) som kommer att rattas av Ulf Ohlsson som alltså avstår loppen på huvudstadsbanan.</p>



<p>En spännande häst i V86-4 är otvivelaktigt Timo Nurmos-tränade treåringen <strong>Pralines</strong> (e. Fabulous Wood) som är obesegrad i tre starter och som gjorde ett mäktigt intryck vid senaste segern där han svepte fältet. Blir det fjärde raka tillsammans med Magnus A Djuse?</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/08/28v86.pdf">Här är startlistorna till tävlingarna på Åby och Solvalla.</a></p>



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



<p class="has-drop-cap">5 Franska travförbundet Société du Trotteur Français (SETF) har offentliggjort sin månadsrapport för juli månad om resultaten av de medicinkontroller som genomförts:</p>



<p>Under juli 2024 togs totalt 1 825 prover och följande kontroller utfördes:</p>



<ul class="wp-block-list">
<li>1.520 hästar provtogs efter att de deltagit i lopp.</li>



<li>35 hästar provtogs vid ankomsten till travbanan och innan de deltog i lopp. Provtagningar organiserades i Vichy (6 juli), La Capelle (7 juli), Biarritz (18 juli), Hyères (21 juli) och 31 juli på Enghien. Under var och en av dessa insatser togs prover på tre hästar.</li>



<li>Två större särskilda insatser organiserades i Pornichet (11 juli) och 26 juli i La Capelle, varav 20 hästar kontrollerades.</li>



<li>Fyra bikarbonatprovtagningar genomfördes på La Capelle (9 juli), Enghien (10, 24 juli) samt i Cabourg 30 juli. Under dessa operationer togs prover på 60 hästar. Alla resultat var negativa.</li>



<li>117 hästar provtogs under kvallopp.</li>



<li>80 hästar provtogs under träningstester på 19 olika träningsanläggningar.</li>
</ul>



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



<p class="has-drop-cap">6 Henrik Hollsten spänner bågen och tävlar på <strong>Vincennes</strong> idag (kl. 14.40) med treårige <strong>Look Rebel </strong>(e. Fabulous Wood) i Prix de Lagny (€40.000) över 2.700 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/skarmavbild20240815kl.14.01.24-617x293.jpg" alt="" class="wp-image-621996"/><figcaption class="wp-element-caption">Look Rebel går undan enkelt från spets för Gabriele Gelormini.</figcaption></figure>



<p>Gabriele Gelormini har kontrakterats och han körde även den treårige hingsten vid segern i förra starten i Prix Algina (€20.000) i Meslay-de-Maine. Bland motståndarna finns Laurent-Claude Abrivards obesegrade Lago de Pervenche (e. Face Time Bourbon).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-08-28/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-08-28/" target="_blank" rel="noreferrer noopener">Här hittar du startlistorna till Vincennes tävlingar. </a></p>



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



<p class="has-drop-cap">7 I skymundan av den stora ettåringsauktionen i Deauville och andra europeiska hölls den 56:e upplagan av Vente de l’A.E.T.C.E. (Association des Éleveurs de Trot du Centre-Est) i måndags i Vichy. Dyrast blev en ettårig hingst efter Prix d’Amérique-vinnaren Hooker Berry.</p>



<p>Trotting Bloodstock betalade 30.000 euro för <strong>Nickel de Villabon</strong>, vars mor <strong>Ambiance du Loisir </strong>(e. Piscou de Villabon), 1.12,9/€178.340, har en startande avkomma sedan tidigare; treåriga <strong>Lolita de Loriol</strong> (e. Bold Eagle), 1.17,7/€6.985.</p>
