
<p class="has-drop-cap wp-block-paragraph">Vi tar ställning och spikar en enkelprocentare inom lördagens V75-omgång som är kryddad med jackpot.</p>



<p class="wp-block-paragraph">Det handlar om Jeppe Juels svenskfödda fyraårssto <strong>Hertz</strong> (V75-2) som gått lite under radarn i födelselandet, men som visat häftiga fartresurser på dansk mark. Genrepet gav bästa tänkbara formbesked och vi tror hon har alla möjligheter att fälla det här motståndet i spurten.</p>



<p class="wp-block-paragraph">Hertz är enkelprocentare och då kan vi kosta på oss att spika en storfavorit som komplement. <strong>Judge D.</strong> (V75-6) vann på just Axevalla under Nyårsafton och visade då prov på en förbättrad startsnabbhet. Den tog honom utan problem till ledningen och vi tror att samma scenario upprepas här och att Bird Parker-sonen står emot hela vägen.</p>



<p class="wp-block-paragraph">För ovanlighetens skull inleder Gulddivisionen (V75-1) lördagsgåtan och i våra ögon är det en öppen historia. Vi streckar sju hästar och håller en extra tumme ur ett spelmässigt perspektiv för hemmahoppet <strong>Dats So Cool</strong> som som vi tycker är underligt lite spelad kontra faktiskt vinstchans.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/01/27v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Axevalla.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-01-27_8_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-01-27_8_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2024-01-27_8_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Gulddivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Beartime</strong> avslutade sylvasst bakom Stoletheshow på Åby, men var inte alls sig lik i den efterföljande guldfinalen på Solvalla. Det kan ha varit så att banunderlaget satte ner honom den dagen och vi vill inte döma hästen för hårt på en sämre prestation. Totalt sett är detta en ganska så trött guldhistoria och spurtstarke Beartime har alla möjligheter att avgöra i spurten även om han skulle sitta sist i fältet när det börjar närma sig upplopp.</li>



<li><strong>Edibear</strong> satt fast i guldloppet i Kalmar för två veckor sedan och det märks att 2022 års derbytrea börjar komma tillbaka till gammal god form. Vi säger inte att han är på topp än, men kurvan pekar onekligen uppåt och det faktum att han är anmäld med jänkarvagn denna gång kittlar därtill.</li>



<li><strong>Rome Pays Off</strong> fick attackera bakifrån i lördags och göra jobb själv, men det slog inte gnistor om honom. Det är tveklöst så att den här hästen är strået vassare när han får gå i ledningen och han är också loppets spetsfavorit, men frågan är bara vad det kommer kosta. På utsidan har han <strong>Osterc</strong> och Torbjörn Simberg lär knappast ta upp initialt när det är guldstart på hemmaplan&#8230;</li>



<li><strong>Dats So Cool</strong> kördes avvaktande i Kalmar och såg fin ut som fastlåst. Han vann Ullbergs Minne på 1.10,4a/1.640 meter hemma på just Axevalla i höstas via tredjespår fram till dödens och är ytterst härdad i den här klassen.</li>



<li><strong>Crack Atout</strong> gynnas inte av att det är sprinterdistans, men däremot är han väldigt bra på att hålla tempot uppe och vi kan se ett scenario av detta lopp där öppningen blir frejdig.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A:</strong> 8-9-1 <strong>B: </strong>7-5-6-3 <strong>C: </strong>2-10-4</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Rome Pays Off </strong>har mycket god chans att hålla upp innerspåret. <strong>Randemar R.D. </strong>lär vikas ner bakom direkt, men däremot brukar inte Torbjörn Simberg ge vika i första taget utan vi kan se honom testa ordentligt med <strong>Osterc</strong>. Antingen för att komma förbi eller för att skapa en lucka bakom och då kan öppningen bli rask.</p>



<h2 class="wp-block-heading">Avd 2 – Diamantstoet, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Hertz</strong> tycker vi tävlar i för låg klass och tillmäter toppchans i den här omgivningen. Hon slog flera av Danmarks bästa ston i kullen i höstas i Ålborg, satt fast med rubbet sparat i ett Breeders Crown-försök på Axevalla i oktober och gick en riktigt bra långspurt senast i Skive utan att hinna ikapp Muscle Crown. Den här uppgiften känns ytterst överkomlig och sitter hon bara hyggligt till när det drar ihop sig så förväntar vi oss helt sonika att hon lägger detta fält på rygg.</li>



<li><strong>Vikens Bonjour</strong> fick ett perfekt lopp i andra utvändigt senast i Mantorp vid V75-segern och kunde vänta med attacken fram tills upploppet. Hon avgjorde på ett tilltalande vis och fortsätter ta stora steg hela tiden. Oavsett om hon når ledningen eller får en ryggresa så är hon med och strider om segern i det här loppet.</li>



<li><strong>Kelly Smartface </strong>har vi väntat på, men mellan varven har Captain Sparrow-dottern gjort oss besvikna. Nu var hon klart positiv vid dödenssegern senast på Solvalla och verkat allmänt uppåt hela vintern. Från spår sju över sprint är inte uppgiften enkel, men är det någon bana där man likväl kan komma in i matchen så är det på just Axevalla.</li>



<li><strong>Mona Moonlight </strong>har tålt offensiva upplägg på sistone och gått undan på rejält vis och visat god inställning. Vi tror att det finns hästar som är bättre i grunden än vad Brillantissime-dottern är, men behandlar ändå formkortet med respekt.</li>



<li><strong>Vicky Montoya </strong>avgjorde lekande lätt senast på Åby och har aldrig varit i bättre form än vad som är fallet just nu. Hon har ett passande smygläge här och kan sitta fint till när det nalkas upplopp.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A: </strong>3 <strong>B: </strong>5-7-6-9-8-11 <strong>C: </strong>1-4-12-10-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Smålömsk inledning. Flera utrustningsändringar på <strong>Marcia Griffiths </strong>kan bättra på hennes startsnabbhet, annars är det <strong>Vikens Bonjour </strong>och <strong>Mona Moonlight </strong>som gör upp.</p>



<h2 class="wp-block-heading">Avd 3 – Diamantstoet, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mose Eagle </strong>fick ta dödens på slutrundan i debuten för Per Henriksen, men kunde likväl plocka ner Albert Zonett i slutskedet. Det var en stark insats och en prestation som stärker upp att det goda rykte stoet har är befogat. Hon stod även för en bra långspurt vid fjärdeplatsen på Åby i september och bör bli tuff att stå emot till slut i det här loppet. </li>



<li><strong>Heartbeat Julie </strong>vann från ledningen i samma klass näst senast och följde upp med ytterligare en spetstriumf senast på Solvalla. Hemmahästen är i absolut toppslag och säljer sig dyrt även här om hon skulle kunna pressa sig till tät ånyo.</li>



<li><strong>Rosemary Tile</strong> blev utan rygg 700 meter före mål i finalen av Diamantstoet senast, men det spelade ingen roll. Hon löste likväl uppgiften och visade att hon har ett brett register. Främst ser vi henne som en riktigt bra spurtare och då är Axevalla helt rätt ställe att befinna sig på.</li>



<li><strong>Mission Beach</strong> har god chans att vinna starten, men vi tror att Marcus Lilius släpper i skede två och försöker ta rygg på Heartbeat Julie. På sina god form känns det inte främmande att hon kan vara med och slåss om en tätplats om det scenariot utspelar sig.</li>



<li><strong>J.J.Another Vinn </strong>visade mycket god form vid skrällsegern senast på Solvalla och står perfekt till med ett andraspår.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A: </strong>10-7 <strong>B: </strong>6-5-2-4<strong> C: </strong>8-9-12-1</p>



<p class="wp-block-paragraph">Spetsstriden: Vi bedömer <strong>Mission Beach</strong> tillräckligt startsnabb för att komma förbi <strong>Global Deadline</strong>. Därefter tror vi att det släpps till <strong>Heartbeat Julie </strong>i nästa skede.</p>



<h2 class="wp-block-heading">Avd 4 – Klass II, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Woodbank</strong> forcerades till ledningen senast i Mantorp efter en tuff inledning och stod i en klass helt för sig den dagen. Motståndet var påtagligt enklare ska sägas, men han stövlade bara ifrån sina konkurrenter och verkade inte trött över målskjutsen. Den här hästen har alltid omgetts av ett gott rykte och nu som sjuåringen ser det ut som det är på väg att släppa ordentligt.</li>



<li><strong>Mayhem Mary </strong>löste det sig både bra och dåligt för senast på Åby positionsmässigt. Johan Untersteiner lyckades till slut ta sig ut i fritt spurtläge och Mayhem Mary hann fram till knapp seger. Att det är vanlig vagn denna gång är inget plus, men vi tycker ändå att den här hästen har varit betydligt bättre med vanlig vagn än vissa av konkurrenterna som behöver skifta sulkytyp nu och håller formstarke Mayhem Mary som ett tidigt bud.</li>



<li><strong>Sabani</strong> är mer stark än snabb och har lagt i en riktig överväxel i slutskedet i de två senaste starterna när huvan har ryckts från hans öron. Efter att inlett karriären med 24 starter utan seger tycks Brioni-sonen nu ha släppt till ordentligt och han ska tillhöra favoritskaran i det här loppet.</li>



<li><strong>Rustico</strong> hakade på bra som trea i samma klass senast i Kalmar. Han har ett utsökt smygläge och det vore inte alls hela världen om han hamnar som trea- eller fyra längs sargen då det brukar öppna upp sig och man i regel får chansen över Axevallas långa upplopp.</li>



<li><strong>Önas Spartacus </strong>blev dragen bakåt av en trött konkurrent 500 meter före mål senast i Mantorp, men lyckades ta sig ut. Han växlade fart direkt, tog sig ikapp per omgående och gick ifrån över spurtrakan. Han tillhör de bättre även i denna omgivning.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A: </strong>1-2-4<strong> B: </strong>8-9-3-6-5 <strong>C: </strong>11-10-7-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Vikens Cashflow</strong> har mycket god spetschans från springspår, men vi tvivlar om att han körs i ledningen över lång distans. <strong>Woodbank</strong> försöker ta sig ut och är aspirant på att få överta tillsammans med <strong>Mayhem Mary</strong> och <strong>Cumulus F.G.</strong></p>



<h2 class="wp-block-heading">Avd 5 – Klass I, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Cassius Clay D.E. </strong>övertygade stort på oss vid V75-segern på just Axevalla under Nyårsafton. Då fick han en dryg väg fram till dödens från spår åtta bakom startbilsvingen, men lyckades likväl plocka ner ledaren Conrads Palle. Det var en riktigt stark insats och nu är hästen tillbaka och tävlar på den nivå som han gjorde i början av sin vistelse på svensk mark. Även om inte Cassius Clay D.E. visat den där hysteriska startsnabbheten tidigare så ska det sägas att det hänt mycket kring honom på senare tid och kombinationen av jänkarvagn och det utsökta innerspåret på Axevalla ger oss anledning att tro att han faktiskt skulle kunna hålla upp ledningen i det här loppet.</li>



<li><strong>No Talking You </strong>kunde Johan Untersteiner köra till ledningen efter ett varv senast på Åby och därefter var det spel mot ett mål. Fyraåringen har haft en mycket fin utvecklingskurva på senare tid och vi tror på intet vis att hans framgångar grundas i enklare vinterkonkurrens utan det finns mycket kapacitet i den här hästen vilket han visade vid V75-segern på just Axevalla under Nyårsafton.</li>



<li><strong>Soundtrack</strong> hade verkligen inte sin bästa dag när han testade i samma klass senast på Åby. Dessförinnan har han visat goda takter i Tomas Malmqvists regi och det märks att han håller hästen högt, men just den här senaste insatsen gör att vi behandlar Ready Cash-sonen med viss försiktighet.</li>



<li><strong>Deon W. </strong>fick en tuff inledning från spår åtta senast fram till ledningen och låg därtill på friskt under resans gång. Det var inte underligt att han gick sig trött till slut och den kortare distans som nu råder tror vi därtill är till hans fördel.</li>



<li><strong>Dogleg </strong>släppte ledningen senast i samma klass och hakade på bra som trea. Hästen står för jämna prestationer och tillhör de hetare i det här loppet på sina goda möjlighet att skaffa sig en position långt fram i fältet direkt.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A: </strong>1 <strong>B:</strong> 8-4-3-5-11-7-6 <strong>C: </strong>9-2-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Innerspår är mycket fördelaktigt på Axevalla och får Stefan Persson minsta känsla av att han kan hålla upp tät med <strong>Cassius Clay D.E.</strong> så tror vi att han är beredd att chansa lite extra. <strong>Deon W.</strong> är tveklöst hotet emot i spetskampen.</p>



<h2 class="wp-block-heading">Avd 6 – Bronsdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Judge D.</strong> kommer från en V75-seger på just Axevalla över kort distans. Då lade han iväg riktigt bra bakom bilen, var aldrig nära att förlora taktpinnen och höll ifrån sig det värsta hotet bestämt. Med två lopp i kroppen bör han bara gå ytterligare framåt och den här hästen har visat sig trivas förträffligt under just den kalla årstiden. Mycket talar för att han även leder det här loppet från start till mål.</li>



<li><strong>Black Fire</strong> utmålades som aspirant till att kunna passera Judge D. initialt senast, men det var verkligen inte ens nära. Han fick istället en tuff väg fram till dödspositionen och höll med tanke på det riktigt bra som gav Judge D. en match in till linjen. Nu har hästen fått gå den tunga vägen två starter i följd vilket kan sätta sig på moralen, men presterar han på samma nivå ånyo är han med och slåss om tätplatserna.</li>



<li><strong>Real Scotch</strong> gick ett starkt slutvarv från sjätte utvändigt senast och nådde andraplatsen bakom Frankie Godiva. Real Scotch var tvåa från ledningen i samma klass i näst senaste starten och höll fullt bra även den dagen, men kanske är hästen allra vassast när han får spara på speeden.</li>



<li><strong>Jello W.</strong> har vunnit två av sina tio försök inom V75 och klarar av tävling med skor utan problem. Han är inte kvick nog för att kunna hålla ledningen och känns därtill vassare över längre distanser, men samtidigt kan han få en gynnsam smygresa i draget nu och spara på krafterna.</li>



<li><strong>Mulberry</strong> har inlett lovande i ny regi och vi har all anledning att tro att Christoffer Eriksson kommer kunna få fram ytterligare växlar i den här hästen. Från spår sju över sprint känns dock uppgiften knivig och vi tror inte att han vinner loppet.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A: </strong>2 <strong>B: </strong>4-6-1-7-5-3-9-10 <strong>C: </strong>11-8-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Judge D. </strong>höll utan problem ut <strong>Black Fire </strong>senast så vi har all anledning att tro att han lyckas upprepa det här. Även <strong>Real Scotch</strong> har visat god startsnabbhet och lär sökas framåt över korta häcken.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Game Brodde</strong> blir vårt tipsval i en lömsk avslutning. Han fick en tuff resa utvändigt ledaren senast och var slagen när galoppen kom i slutkurvan. Gången innan kom han bort helt positionsmässigt och det är lite svårt att tolka hans formstatus just nu, men löper hästen upp till sin högstanivå så har han jättechans att fälla det här gänget i spurten.</li>



<li><strong>Grappa Boy </strong>gick en riktigt bra långspurt som trea i Silverdivisionen i comebacken efter sju veckors tävlingspaus. Han kan gå framåt ytterligare med det loppet i kroppen och det kittlar därtill att han är anmäld med jänkarvagn denna gång.</li>



<li><strong>Bottnas Idol</strong> löste uppgiften via dödens sista 1.100 meterna senast på Åby och var klart rejäl. Över den här distansen hävdar han sig i denna klass, men vi tycker ändå att han behöver växa in lite ytterligare i sammanhanget för att kännas så pass het att vi placerar honom överst i ranken.</li>



<li><strong>S.G.Mistral</strong> galopperade från start i Silverdivisionen för tre veckor sedan och fick aldrig visa vad han kunde den gången. Dessförinnan avslutade han strålande som tvåa i en Bronsdivisionsfinal och även om segrarna inte duggar tätt för den här femåringen tycker vi att han känns aktuell i det här loppet.</li>



<li><strong>Olga Utca</strong> flög fram i spurten senast i Diamantstoet och höll emot Betting Pacer när det stod och vägde. Hon kan knappast vara med i någon spetskamp här, men har alla möjligheter att få ett smaskigt lopp i draget.</li>



<li><strong>Combat Fighter</strong> var läcker från tät på Romme, men vi ställer oss lite tveksamma till om han orkar stå emot över lång distans om han körs i samma position.</li>
</ul>



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



<p class="wp-block-paragraph"><strong>A: </strong>2-11-5-9<strong> B: </strong>1-6-3-7-4 <strong>C: </strong>8-12-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Combat Fighter </strong>bombar till tät om Anders Svanstedt skickar iväg honom med full kraft och vi tror att han kör i ledningen trots att det handlar om lång distans. Annars ä<strong>r King of Greenwood </strong>sannolikt först fram och övertar.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 27 JANUARI								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,3,5,6,7,8,9 (2,10)<br><strong>Avd 2: </strong>3 Hertz (5,7)<br><strong>Avd 3: </strong>6,7,10 (5,2)<br><strong>Avd 4: </strong>1,2,3,4,5,6,8,9 (11,10)<br><strong>Avd 5: </strong>1,3,4,5,8 (11,7)<br><strong>Avd 6: </strong>2 Judge D. (4,6)<br><strong>Avd 7: </strong>1,2,5,9,11 (6,3)</p>



<p class="wp-block-paragraph"><em>4.200 rader / 2.100 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
